Administración de ramas

Cree y administre ramas para admitir diferentes flujos de trabajo de desarrollo, escenarios de prueba y entornos de producción. Las ramas permiten trabajar con entornos de base de datos aislados sin afectar a la producción.

Descripción de las ramas

Introducción a la rama

Una rama de Lakebase Postgres es un entorno de base de datos independiente que comparte almacenamiento con su rama primaria a través de la copia en escritura. Las ramas le permiten:

• Creación de entornos de desarrollo y pruebas aislados
• Probar aplicaciones con conjuntos de datos realistas
• Implementación de flujos de trabajo de desarrollo de bases de datos

Estrategias y tipos de rama

Al crear una rama, puede elegir entre varias opciones en función de sus necesidades específicas. Cada opción crea una rama con diferentes características de datos y casos de uso.

Expiración de la rama

La caducidad de las ramas le permite establecer marcas de tiempo de eliminación automática en las ramas. Cuando una rama alcanza su hora de expiración, se elimina automáticamente. Esta característica ayuda a administrar ramas temporales y a reducir los costos de almacenamiento.

Por qué utilizar la caducidad de las ramas

La caducidad de las ramas es ideal para ramas temporales que tienen una vida útil predecible:

• Entornos de CI/CD: Ramas de prueba que deben eliminarse tras la finalización del pipeline.
• Desarrollo de características: Ramas de características limitadas en el tiempo con fechas límite conocidas.
• Pruebas automatizadas: Entornos de prueba efímeros creados por scripts.
• Flujos de trabajo de desarrollo: Entornos temporales que no necesitan conservarse indefinidamente.

Sin expiración automática, estas ramas se acumulan con el tiempo, lo que aumenta los costos de almacenamiento y el desorden del proyecto.

Cómo funciona la caducidad de las ramas

La caducidad de las ramas utiliza un modelo de tiempo de vida (TTL). Cuando se establece una expiración en una rama, se define cuánto tiempo debe existir la rama antes de la eliminación automática.

Al establecer una marca de tiempo de expiración en una rama:

1. El sistema almacena la marca de tiempo de expiración (la fecha y hora programadas en que se eliminará la rama) y el intervalo de TTL (la duración entre la creación o actualización y la expiración).
2. Un proceso en segundo plano supervisa las ramas y las elimina después de que se alcance su tiempo de expiración.
3. Si restableces una rama desde su rama principal, la cuenta atrás del TTL se reinicia utilizando el intervalo original.

Restricciones de la caducidad de las ramas

Para mantener la integridad del sistema, no se pueden agregar marcas de tiempo de expiración a:

• Ramas protegidas: No se pueden eliminar ramas protegidas ni proteger ramas con expiración.
• Ramas predeterminadas: No se pueden expirar las ramas predeterminadas ni establecer ramas que expiran como predeterminadas.
• Ramas principales: No se pueden hacer caducar ramas que tengan ramas secundarias ni crear ramas secundarias a partir de ramas que estén a punto de caducar.

Período de expiración máximo

El período de expiración máximo es de 30 días a partir de la hora actual. Si necesita que una rama perdure más de 30 días, puede actualizar la marca temporal de caducidad antes de que expire para prolongar su duración.

Creación y administración de ramas

Creación de una rama

Para crear una rama:

Interfaz de usuario

1. Dirígete a la página Ramas de tu proyecto en la aplicación Lakebase.
2. Haga clic en Crear rama y configure las opciones de rama:
   • Escriba un nombre de rama (obligatorio)
   • Seleccione una opción de rama (Datos de rama y esquema o Datos de rama y esquema de un momento pasado)
   • Opcionalmente, establezca una expiración mediante la lista desplegable Eliminación automática: elija un valor preestablecido (después de 1 hora, después de 1 día o después de 7 días), un valor personalizado (hasta 30 días) o Nunca sin expiración. Consulte Expiración de la rama para obtener más información.
3. Haga clic en Crear para crear la rama.

SDK de Python

Especifique una directiva de expiración mediante una de las siguientes opciones en BranchSpec:

• ttl: un Duration objeto (por ejemplo: Duration(seconds=604800) durante 7 días)
• expire_time: una expiración específica datetime
• no_expiry=True: Para ramas que nunca deben caducar

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Branch, BranchSpec, Duration

w = WorkspaceClient()

# Create branch with 7-day expiration
branch_spec = BranchSpec(
    ttl=Duration(seconds=604800),  # 7 days
    source_branch="projects/my-project/branches/production"
)

branch = Branch(spec=branch_spec)

result = w.postgres.create_branch(
    parent="projects/my-project",
    branch=branch,
    branch_id="development"
).wait()

print(f"Branch created: {result.name}")
print(f"Expires: {result.status.expire_time}")

Para crear una rama permanente sin expiración, establezca no_expiry=True en :BranchSpec

# Create a permanent branch (no expiration)
branch_spec = BranchSpec(
    source_branch="projects/my-project/branches/production",
    no_expiry=True
)

branch = Branch(spec=branch_spec)

result = w.postgres.create_branch(
    parent="projects/my-project",
    branch=branch,
    branch_id="staging"
).wait()

print(f"Branch created: {result.name}")

SDK de Java

Especifique una directiva de expiración mediante una de las siguientes opciones en BranchSpec:

• setTtl(Duration): un com.google.protobuf.Duration objeto (por ejemplo: Duration.newBuilder().setSeconds(604800L).build() durante 7 días)
• setExpireTime(Timestamp): una expiración específica com.google.protobuf.Timestamp
• setNoExpiry(true): Para ramas que nunca deben caducar

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.Duration;

WorkspaceClient w = new WorkspaceClient();

// Create branch with 7-day expiration
BranchSpec branchSpec = new BranchSpec()
    .setTtl(Duration.newBuilder().setSeconds(604800L).build())  // 7 days
    .setSourceBranch("projects/my-project/branches/production");

Branch branch = new Branch().setSpec(branchSpec);

Branch result = w.postgres().createBranch(
    new CreateBranchRequest()
        .setParent("projects/my-project")
        .setBranch(branch)
        .setBranchId("development")
).waitForCompletion();

System.out.println("Branch created: " + result.getName());
System.out.println("Expires: " + result.getStatus().getExpireTime());

Para crear una rama permanente sin expiración, establezca no_expiry=true en :BranchSpec

// Create a permanent branch (no expiration)
BranchSpec branchSpec = new BranchSpec()
    .setSourceBranch("projects/my-project/branches/production")
    .setNoExpiry(true);

Branch branch = new Branch().setSpec(branchSpec);

Branch result = w.postgres().createBranch(
    new CreateBranchRequest()
        .setParent("projects/my-project")
        .setBranch(branch)
        .setBranchId("staging")
).waitForCompletion();

System.out.println("Branch created: " + result.getName());

Interfaz de línea de comandos (CLI)

Especifique una directiva de expiración con uno de los campos siguientes en json spec :

• ttl: cadena de duración (por ejemplo: "604800s" durante 7 días)
• expire_time: marca de tiempo ISO 8601 (ejemplo: "2025-01-15T10:30:00Z")
• no_expiry: true: Para ramas que nunca deben caducar

# Create a branch with 7-day expiration
databricks postgres create-branch projects/my-project development \
  --json '{
    "spec": {
      "source_branch": "projects/my-project/branches/production",
      "ttl": "604800s"
    }
  }'

# Create a permanent branch (no expiration)
databricks postgres create-branch projects/my-project staging \
  --json '{
    "spec": {
      "source_branch": "projects/my-project/branches/production",
      "no_expiry": true
    }
  }'

curl

Especifique una directiva de expiración mediante uno de los campos siguientes en el json del cuerpo de la solicitud:

• ttl: cadena de duración (por ejemplo: "604800s" durante 7 días)
• expire_time: marca de tiempo ISO 8601 (ejemplo: "2025-01-15T10:30:00Z")
• no_expiry: true: Para ramas que nunca deben caducar

# Create a branch with 7-day expiration
curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches?branch_id=development" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "source_branch": "projects/my-project/branches/production",
      "ttl": "604800s"
    }
  }' | jq

# Create a permanent branch (no expiration)
curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches?branch_id=staging" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "source_branch": "projects/my-project/branches/production",
      "no_expiry": true
    }
  }' | jq

Ver ramas

Ver en la interfaz de usuario

Para ver todas las ramas del proyecto de Lakebase, seleccione el proyecto en la aplicación lakebase y vaya a Ramas en el panel de navegación izquierdo.

La tabla de ramas muestra información clave sobre cada rama:

La página de ramas muestra una tabla completa con información sobre cada rama de tu proyecto:

Haga clic en cualquier rama de la tabla para ver la página de información general de la rama, que muestra información detallada sobre la rama seleccionada:

La página de información general de la rama muestra información detallada en la parte superior, incluidas las métricas clave y los metadatos:

La página de información general de la rama incluye varias pestañas para administrar distintos aspectos de la rama:

Obtención de una rama mediante programación

Para obtener detalles sobre una rama específica mediante postgres API:

SDK de Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Get branch details
branch = w.postgres.get_branch(
    name="projects/my-project/branches/development"
)

print(f"Branch: {branch.name}")
print(f"Protected: {branch.status.is_protected}")
print(f"Default: {branch.status.default}")
print(f"State: {branch.status.current_state}")
print(f"Size: {branch.status.logical_size_bytes} bytes")

SDK de Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.Branch;

WorkspaceClient w = new WorkspaceClient();

// Get branch details
Branch branch = w.postgres().getBranch("projects/my-project/branches/development");

System.out.println("Branch: " + branch.getName());
System.out.println("Protected: " + branch.getStatus().getIsProtected());
System.out.println("Default: " + branch.getStatus().getDefault());
System.out.println("State: " + branch.getStatus().getCurrentState());
System.out.println("Size: " + branch.getStatus().getLogicalSizeBytes() + " bytes");

Interfaz de línea de comandos (CLI)

# Get branch details
databricks postgres get-branch projects/my-project/branches/development --output json | jq

curl

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/development" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Listar mediante programación

Para enumerar todas las ramas de un proyecto mediante postgres API:

SDK de Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# List all branches in a project
project_name = "projects/my-project"
branches = list(w.postgres.list_branches(parent=project_name))

for branch in branches:
    print(f"Branch: {branch.name}")
    print(f"  Default: {branch.status.default}")
    print(f"  Protected: {branch.status.is_protected}")

SDK de Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;

WorkspaceClient w = new WorkspaceClient();

// List all branches in a project
String projectName = "projects/my-project";

for (Branch branch : w.postgres().listBranches(projectName)) {
    System.out.println("Branch: " + branch.getName());
    System.out.println("  Default: " + branch.getStatus().getDefault());
    System.out.println("  Protected: " + branch.getStatus().getIsProtected());
}

Interfaz de línea de comandos (CLI)

# List all branches in a project
databricks postgres list-branches projects/my-project --output json | jq

curl

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" | jq

Comparación de esquemas de rama

Revise las diferencias de esquema entre una rama hija y su rama madre antes de fusionar los cambios. La comparación de esquemas muestra una comparación DDL de SQL en paralelo que resalta los objetos de la base de datos añadidos, eliminados o modificados, como tablas, columnas, índices y restricciones.

Para comparar esquemas entre ramas:

1. Vaya a la página de descripción general de una sucursal secundaria en la aplicación Lakebase.
2. En la sección Rama principal, haga clic en Diferencias de esquema.
3. En el cuadro de diálogo Diferencias de esquema:
   • Base: seleccione la rama base para la comparación (el valor predeterminado es la rama primaria).
   • Base de datos: seleccione la base de datos que se va a comparar.
   • Comparar: seleccione la rama que se va a comparar con base (el valor predeterminado es la rama secundaria actual).
4. Haga clic en Compare (Comparar).

Interpretación de los resultados de la comparación

Cuando los esquemas difieren, la vista de diferencias muestra una comparación en paralelo de las instrucciones DDL de SQL:

Las líneas rojas muestran lo que se quitó o cambió de la rama base, las líneas verdes muestran lo que se agregó o cambió en la rama de comparación. El diff captura los cambios en las definiciones de tabla, columnas, restricciones, índices y otros objetos de la base de datos.

Si no existen diferencias entre las ramas seleccionadas, verá un mensaje de confirmación de que los esquemas están sincronizados:

Utiliza el 'schema diff' para la validación previa a la combinación, el seguimiento del desarrollo, la detección de desviación y la documentación de cambios. Para ver la diferencia de esquema en un flujo de trabajo de desarrollo completo, consulte Tutorial: Flujo de trabajo de desarrollo basado en rama.

Actualizar la configuración de la rama

Cambiar el nombre de una rama

El cambio de nombre de una rama no se admite actualmente desde la interfaz de usuario o la API. La opción Renombrar rama aparece en el menú de la rama de la interfaz de usuario, pero está desactivada.

Establecer como valor predeterminado

Cada proyecto de Lakebase se crea con una rama predeterminada denominada production, pero puede designar cualquier rama como predeterminada. La rama predeterminada está exenta del límite de proceso activo simultáneamente, lo que garantiza que permanece disponible en todo momento.

Para establecer una rama como predeterminada:

1. Dirígete a la página Ramas de tu proyecto en la aplicación Lakebase.
2. Haga clic en el menú situado junto a la rama que desea establecer como predeterminada.
3. Seleccione Establecer como valor predeterminado y confirme la operación.

Establecer como protegido

Las ramas protegidas ayudan a proteger las ramas críticas frente a modificaciones o eliminaciones accidentales. Las ramas protegidas no se pueden eliminar, restablecer ni archivar debido a la inactividad. Los proyectos con ramas protegidas y sus procesos asociados tampoco se pueden eliminar.

Para establecer una rama como protegida:

Interfaz de usuario

1. Vaya a Ramas en la aplicación Lakebase y seleccione la rama que desea proteger.
2. Haga clic en Proteger y confirme la selección.

La rama ahora está designada como protegida, como se indica en el icono de escudo que aparece junto al nombre de la rama.

SDK de Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Branch, BranchSpec, FieldMask

w = WorkspaceClient()

# Set a branch as protected
branch_name = "projects/my-project/branches/production"

updated_spec = BranchSpec(is_protected=True)
updated_branch = Branch(name=branch_name, spec=updated_spec)
update_mask = FieldMask(field_mask=["spec.is_protected"])

update_op = w.postgres.update_branch(
    name=branch_name,
    branch=updated_branch,
    update_mask=update_mask
)

# Wait for the update to complete
result = update_op.wait()
print(f"Branch {result.name} is now protected: {result.status.is_protected}")

Para quitar la protección, establezca is_protected=False en el BranchSpec.

SDK de Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.FieldMask;

WorkspaceClient w = new WorkspaceClient();

// Set a branch as protected
String branchName = "projects/my-project/branches/production";

BranchSpec updatedSpec = new BranchSpec().setIsProtected(true);
Branch updatedBranch = new Branch()
    .setName(branchName)
    .setSpec(updatedSpec);
FieldMask updateMask = FieldMask.newBuilder()
    .addPaths("spec.is_protected")
    .build();

Branch result = w.postgres().updateBranch(
    new UpdateBranchRequest()
        .setName(branchName)
        .setBranch(updatedBranch)
        .setUpdateMask(updateMask)
).waitForCompletion();

System.out.println("Branch " + result.getName() + " is now protected: " +
    result.getStatus().getIsProtected());

Para quitar la protección, establezca setIsProtected(false) en el BranchSpec.

Interfaz de línea de comandos (CLI)

# Set a branch as protected
databricks postgres update-branch projects/my-project/branches/production spec.is_protected \
  --json '{
    "spec": {
      "is_protected": true
    }
  }'

Para quitar la protección, establezca "is_protected": false en json.

curl

curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production?update_mask=spec.is_protected" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production",
    "spec": {
      "is_protected": true
    }
  }' | jq

Para quitar la protección, establezca "is_protected": false en el cuerpo de la solicitud.

Para obtener detalles completos sobre las ramas protegidas, incluida la administración de contraseñas para ramas secundarias, consulte Ramas protegidas.

Fecha de caducidad de la actualización

Puede establecer una marca de tiempo de expiración al crear una rama o actualizarla más adelante.

Al crear una rama

1. Dirígete a la página Ramas de tu proyecto en la aplicación Lakebase.
2. Haga clic en Crear rama, escriba un nombre de rama (obligatorio), configure las opciones de rama y seleccione una opción De eliminación automática (un valor preestablecido, un valor personalizado de hasta 30 días o Nunca para que no expire).
3. Haga clic en Crear.

Actualizar la fecha de caducidad de la rama

Para actualizar o quitar una marca de tiempo de expiración en una rama existente:

Interfaz de usuario

1. Dirígete a la página Ramas de tu proyecto en la aplicación Lakebase.
2. Haz clic en el menú situado junto a la rama y selecciona Actualizar fecha de caducidad.
3. Selecciona una nueva fecha y hora o desmarca Caducidad de la rama el para eliminar la fecha de caducidad y, a continuación, haz clic en Guardar.

SDK de Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Branch, BranchSpec, Duration, FieldMask

w = WorkspaceClient()

# Update branch expiration to 14 days
branch_name = "projects/my-project/branches/development"

branch_spec = BranchSpec(
    is_protected=False,
    ttl=Duration(seconds=1209600)  # 14 days
)
branch = Branch(
    name=branch_name,
    spec=branch_spec
)

result = w.postgres.update_branch(
    name=branch_name,
    branch=branch,
    update_mask=FieldMask(field_mask=["spec.is_protected", "spec.expiration"])
).wait()

print(f"Updated expiration: {result.status.expire_time}")

Para quitar la expiración, establezca no_expiry=True en BranchSpec e incluya "spec.expiration" en la máscara de actualización.

SDK de Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.Duration;
import com.google.protobuf.FieldMask;

WorkspaceClient w = new WorkspaceClient();

// Update branch expiration to 14 days
String branchName = "projects/my-project/branches/development";

BranchSpec branchSpec = new BranchSpec()
    .setIsProtected(false)
    .setTtl(Duration.newBuilder().setSeconds(1209600L).build());  // 14 days

Branch branch = new Branch()
    .setName(branchName)
    .setSpec(branchSpec);

Branch result = w.postgres().updateBranch(
    new UpdateBranchRequest()
        .setName(branchName)
        .setBranch(branch)
        .setUpdateMask(FieldMask.newBuilder()
            .addPaths("spec.is_protected")
            .addPaths("spec.expiration")
            .build())
).waitForCompletion();

System.out.println("Updated expiration: " + result.getStatus().getExpireTime());

Para quitar la expiración, establezca setNoExpiry(true) en BranchSpec e incluya "spec.expiration" en la máscara de actualización.

Interfaz de línea de comandos (CLI)

# Update branch expiration to 14 days
databricks postgres update-branch projects/my-project/branches/development spec.is_protected,spec.expiration \
  --json '{
    "spec": {
      "is_protected": false,
      "ttl": "1209600s"
    }
  }'

Para quitar la expiración, establezca "no_expiry": true en json.

curl

# Update branch expiration to 14 days
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/development?update_mask=spec.is_protected,spec.expiration" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/development",
    "spec": {
      "is_protected": false,
      "ttl": "1209600s"
    }
  }' | jq

Para quitar la expiración, establezca "no_expiry": true en el cuerpo de la solicitud.

Visualización de la expiración de la rama

Para comprobar si una rama tiene un conjunto de expiración, vaya a la página Ramas del proyecto y haga clic en la rama deseada. La información de vencimiento se muestra en los detalles de la sucursal.

Restablecer la rama a partir de la rama principal

Puede restablecer una rama para actualizarla al instante con el esquema y los datos más recientes de su rama primaria. Esto le ayuda a recuperarse de problemas, empezar a desarrollar nuevas características o mantener sincronizadas las distintas ramas del entorno.

Escenario de ejemplo

Al trabajar con ramas, es posible que se encuentre en una situación en la que necesite actualizar la rama de trabajo a los datos más recientes de la rama primaria.

Por ejemplo, supongamos que tienes dos ramas secundarias staging y development creadas a partir de tu rama production. Has estado trabajando en la rama development y te das cuenta de que ahora está demasiado desactualizada con respecto a production.

No tiene cambios de esquema en development que considere o deba conservar; solo desea una actualización rápida de los datos. Puedes realizar un restablecimiento limpio e instantáneo a los datos más recientes de la rama principal en una sola operación, lo que te ahorra la complicación de crear y restaurar ramas manualmente.

Cómo funciona el reinicio desde el elemento principal

Al restablecer una rama a su elemento primario, los datos y el esquema se reemplazan por los datos y el esquema más recientes de su elemento primario.

Puntos clave:

• Solo puedes restablecer una rama con los datos más recientes de su rama principal. Los restablecimientos a un momento dado basados en la marca de tiempo son posibles mediante la restauración a un momento dado, una característica similar con algunas diferencias: la restauración a un momento dado crea una nueva rama y está pensada más para la recuperación de datos que el flujo de trabajo de desarrollo.
• Este restablecimiento es una sobrescritura completa, no una actualización o una combinación. Los cambios locales realizados en la rama secundaria se pierden durante este restablecimiento.
• Las conexiones existentes se interrumpen temporalmente durante el restablecimiento. Sin embargo, los detalles de conexión no cambian. Todas las conexiones se vuelven a establecer en cuanto se realiza el restablecimiento.
• Las ramas raíz (como la rama del production proyecto) no se pueden restablecer porque no tienen ninguna rama primaria a la que restablecer.

Restablecer una rama desde su rama principal

Para restablecer una rama a su elemento primario:

1. Dirígete a la página Ramas de tu proyecto en la aplicación Lakebase.
2. Haga clic en el icono situado junto a la rama que desea restablecer y seleccione Restablecer desde elemento principal.
3. Confirme la operación de restablecimiento.

Eliminación de una rama

Para eliminar una rama:

Interfaz de usuario

1. Dirígete a la página Ramas de tu proyecto en la aplicación Lakebase.
2. Haga clic en el menú situado junto a la rama que desea eliminar y seleccione Eliminar rama.
3. Escriba el nombre de la rama para confirmar la eliminación y haga clic en Eliminar.

SDK de Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Delete branch
w.postgres.delete_branch(
    name="projects/my-project/branches/development"
).wait()

print("Branch deleted")

La operación de eliminación es asincrónica. El .wait() método se bloquea hasta que se complete la eliminación. Todos los recursos de rama (bases de datos, roles, procesos y datos) se eliminarán permanentemente.

SDK de Java

import com.databricks.sdk.WorkspaceClient;

WorkspaceClient w = new WorkspaceClient();

// Delete branch
w.postgres().deleteBranch("projects/my-project/branches/development")
    .waitForCompletion();

System.out.println("Branch deleted");

La operación de eliminación es asincrónica. El waitForCompletion() método se bloquea hasta que se complete la eliminación. Todos los recursos de rama (bases de datos, roles, procesos y datos) se eliminarán permanentemente.

Interfaz de línea de comandos (CLI)

# Delete a branch
databricks postgres delete-branch projects/my-project/branches/development

Este comando devuelve inmediatamente. La rama y todos sus recursos se eliminarán permanentemente.

curl

curl -X DELETE "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/development" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Respuesta:

{
  "name": "projects/my-project/branches/development/operations/...",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

Archivado automático de ramas

Para optimizar el uso de recursos, Lakebase archiva automáticamente las ramas inactivas. El archivado se administra mediante el sistema. Una rama con un proceso en ejecución nunca se archiva y una rama sin un proceso en ejecución se puede archivar después de un período de inactividad. El archivado no afecta a los datos o la configuración de la rama.

Las ramas protegidas no se archivan. Consulte Ramas protegidas.

Desarchivar una rama

No es necesario desarchivar una rama manualmente. Lakebase desarchiva automáticamente una rama cuando se accede a ella, como al conectarse a ella, consultarla, ver sus tablas o crear una rama secundaria. Cuando una rama no está archivada, sus ramas primarias hasta la rama raíz también se desarchivan.

Las ramas con grandes volúmenes de datos pueden tener tiempos de conexión y de consulta algo más lentos mientras se completa la desarchivación.