ger ramos

info

O dimensionamento automático do Lakebase está disponível nas seguintes regiões: us-east-1, us-east-2, eu-central-1, eu-west-1, eu-west-2, ap-south-1, ap-southeast-1, ap-southeast-2.

O Lakebase autoscale é a versão mais recente do Lakebase com recursos como autoscale compute, escala-to-zero, branching e instant restore. Para comparação de recursos com o provisionamento do Lakebase, veja escolhendo entre versões.

Criar e gerenciar branches para suportar diferentes fluxos de trabalho de desenvolvimento, cenários de teste e ambientes de produção. Os branches permitem trabalhar com ambientes de banco de dados isolados sem afetar a produção.

nota

Sobre as permissões de gerenciamento de filiais:

Para criar, excluir ou atualizar ramificações, você precisa da permissão CAN MANAGE no projeto. Consulte as permissões de gerenciamento do projeto.
Para criar bancos de dados ou funções dentro de uma ramificação, você precisa da permissão CAN MANAGE no projeto.
Para saber mais sobre como funciona o ramificação, incluindo relações pai-filho, armazenamento copy-on-write e estratégias de ramificação, consulte Ramificações de banco de dados.

Entendendo os ramos

Visão geral da filial

Uma ramificação no Lakebase Postgres é um ambiente de banco de dados independente que compartilha armazenamento com sua ramificação pai por meio de cópia em gravação (copy-on-write). As agências permitem que você:

Criar ambientes isolados de desenvolvimento e teste
Teste as aplicações com conjuntos de dados realistas.
Implementar fluxo de trabalho de desenvolvimento de banco de dados

Tipos e estratégias de agências

Ao criar uma filial, você pode escolher entre diversas opções, dependendo das suas necessidades específicas. Cada opção cria uma ramificação com diferentes características de dados e casos de uso.

Opção	Descrição
Dados atuais	Cria uma ramificação a partir do estado mais recente da sua ramificação principal. Ideal para desenvolvimento, testes com dados atuais e ramificações de recursos.
Dados passados	Cria uma ramificação a partir de um ponto específico no tempo dentro da sua janela de restauração. Útil para recuperação pontual, análise histórica, cenários de reversão e consulta de dados em um ponto específico no tempo. Use o seletor de datas para escolher o momento desejado.

Expiração do ramo

O recurso de expiração de branches permite definir datas de exclusão automática para os branches. Quando um ramo atinge o tempo de expiração, ele é excluído automaticamente. Este recurso ajuda a gerenciar filiais temporárias e a reduzir os custos de armazenamento.

Por que usar a expiração de ramificação?

O recurso de expiração de ramificações é ideal para ramificações temporárias com duração previsível:

Ambientes CI/CD: Branches de teste que devem ser limpas após a conclusão do pipeline.
Desenvolvimento de recursos: ramificações de recursos com tempo definido e prazos conhecidos.
Testes automatizados: Ambientes de teste efêmeros criados por scripts.
Fluxo de trabalho de desenvolvimento: Ambientes temporários que não precisam persistir indefinidamente.

Sem expiração automática, esses ramos se acumulam ao longo do tempo, aumentando os custos de armazenamento e a desorganização dos projetos.

dica

Exemplo de prazo de validade: pipeline CI/CD (2 a 4 horas), demos (24 a 48 horas), desenvolvimento de recursos (1 a 7 dias), testes de longo prazo (30 dias).

Como funciona o vencimento de branches

O vencimento de branches utiliza um modelo de tempo de vida (TTL). Ao definir um prazo de expiração para uma ramificação, você está definindo por quanto tempo a ramificação deve existir antes de ser excluída automaticamente.

Ao definir um carimbo de data/hora de expiração em uma ramificação:

O sistema armazena tanto o carimbo de data/hora de expiração (a data e hora programadas para a exclusão da ramificação) quanto o intervalo TTL (a duração entre a criação ou atualização e a expiração).
Um processo em segundo plano monitora as ramificações e as exclui após o tempo de expiração ser atingido.
Se você redefinir uma ramificação a partir de seu pai, a contagem regressiva do TTL será reiniciada usando o intervalo original.

importante

A exclusão de um ramo é permanente e irreversível. Todos os dados e recursos compute associados também são excluídos. Verifique cuidadosamente os prazos de validade antes de configurá-los.

Restrições de vencimento de filiais

Para manter a integridade do sistema, não é possível adicionar carimbos de data/hora de expiração a:

Ramos protegidos: Não é possível expirar ramos protegidos nem proteger ramos com expiração.
Ramos padrão: Não é possível expirar ramos default nem definir ramos expirados como default.
Ramos principais: Não é possível expirar ramos que possuem ramos filhos, nem criar ramos filhos a partir de ramos que estão expirando.

nota

Quando uma ramificação expira e é excluída, todos os recursos compute associados também são excluídos. Garanta que todas as cargas de trabalho críticas sejam migradas antes do vencimento.

Período máximo de validade

O prazo máximo de validade é de 30 dias a partir da data atual. Se você precisar que uma ramificação persista por mais de 30 dias, poderá atualizar o carimbo de data/hora de expiração antes que ela expire para estender seu tempo de vida.

Criar e gerenciar filiais

Criar uma ramificação

Para criar uma ramificação:

UI
Python SDK
Java SDK
CLI
curl

Acesse a página de ramificações do seu projeto no aplicativo Lakebase.
Clique em Criar ramificação e configure as opções da sua ramificação:
- Insira um nome descritivo para a filial (obrigatório)
- Selecione o tipo de ramificação desejado (Dados atuais ou Dados anteriores)
- Opcionalmente, defina um tempo de expiração para a exclusão automática marcando a opção Expirar ramo após e selecionando uma predefinição (1 hora, 1 dia ou 7 dias). Consulte a seção "Expiração da filial" para obter detalhes.
- Configure quaisquer definições adicionais para a opção escolhida.
Clique em Criar para criar a ramificação.

Diálogo de criação de ramificação

Python
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 criar uma ramificação permanente sem expiração, defina no_expiry=True em BranchSpec:

Python
# 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}")

Java
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 criar uma ramificação permanente sem expiração, defina no_expiry=true em BranchSpec:

Java
// 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());

Bash
# 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
    }
  }'

Bash
# 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

Ao criar uma ramificação usando a API ou a CLI, você deve especificar uma política de expiração usando uma das seguintes opções:

ttl: duração em segundos (exemplo: "604800s" por 7 dias)
expire_timeCarimbo de data/hora ISO 8601 para uma data e hora específicas.
no_expiry: truePara ramos que nunca devem expirar

ver ramos

Visualizar na interface do usuário

Para view todas as ramificações do seu projeto no Lakebase, selecione o projeto no aplicativo Lakebase e navegue até "Ramais" na barra de navegação à esquerda.

A tabela de filiais exibe informações key sobre cada filial:

Tabela de ramos

A página de ramificações exibe uma tabela completa com informações sobre cada ramificação do seu projeto:

Coluna	Descrição
Ramo	O nome da filial. O ramo default exibe um rótulo "padrão".
Pai	Indica a ramificação pai a partir da qual esta ramificação foi criada, ajudando você a rastrear a hierarquia de ramificações.
Tempo ativo	Número de horas em que o compute da filial esteve ativo.
computeprimário	Mostra o tamanho e o status atuais compute (como parado ou ATIVO) do compute da ramificação.
Tamanho dos dados	Indica o tamanho lógico dos dados da ramificação. O tamanho dos dados não inclui história.
Criado por	O usuário ou serviço que criou a ramificação.
Última atividade	Mostra quando o compute da ramificação esteve ativo pela última vez.

Clique em qualquer ramo da tabela para view a página de visão geral do ramo, que exibe informações detalhadas sobre o ramo selecionado:

Página de visão geral da filial

A página de visão geral da filial exibe informações detalhadas na parte superior, incluindo métricas e metadados key :

campo	Descrição
ID	O identificador único da filial (com o prefixo br-)
Criado em	A data e a hora em que a filial foi criada.
calcular horas	Total de horas compute utilizadas pela filial
Horário ativo	calcular horas utilizadas desde uma data específica
Tamanho dos dados	O tamanho lógico dos dados do ramo (não inclui o espaço em branco)
Criado por	O usuário que criou a ramificação

A página de visão geral da filial inclui várias abas para gerenciar diferentes aspectos da filial:

Tab	Descrição
calcular	Visualizar e gerenciar o compute principal da filial. Veja gerenciar computação.
Funções e Bancos de Dados	Gerenciar funções de banco de dados e bancos de dados associados à filial. Consulte gerenciar bancos de dados e gerenciar funções.
Ramos filhos	Veja quaisquer ramificações que foram criadas a partir desta ramificação.

Obtenha uma ramificação programaticamente

Para obter detalhes sobre uma ramificação específica usando a API do Postgres:

Python SDK
Java SDK
CLI
curl

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")

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");

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

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

Listar programaticamente

Para listar todas as ramificações de um projeto usando a API do Postgres:

Python SDK
Java SDK
CLI
curl

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}")

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());
}

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

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

Comparar esquemas de ramificação

Analise as diferenças de esquema entre um ramo filho e seu ramo pai antes de mesclar as alterações. A comparação de esquemas mostra uma comparação lado a lado do DDL SQL, destacando objetos de banco de dados adicionados, removidos ou modificados, como tabelas, colunas, índices e restrições.

Para comparar esquemas entre filiais:

Acesse a página de visão geral de uma ramificação filha no aplicativo Lakebase.
Na seção Ramificação principal , clique em Diferença de esquema .
Na caixa de diálogo Diferença de Esquema:
- Base : Selecione o ramo base para comparação (o padrão é o ramo pai).
- Banco de dados : Selecione o banco de dados a ser comparado.
- Comparar : Selecione a ramificação a ser comparada com a ramificação base (por padrão, a ramificação filha atual).
Clique em Comparar .

Entenda os diferentes resultados

Quando os esquemas diferem, a view de diferenças exibe uma comparação lado a lado das instruções SQL DDL:

Diferenças de esquema mostrando as diferenças entre ramificações com alterações de DDL SQL codificadas por cores

As linhas vermelhas mostram o que foi removido ou alterado no ramo base, enquanto as linhas verdes mostram o que foi adicionado ou alterado no ramo de comparação. O diff captura as alterações nas definições de tabelas, colunas, restrições, índices e outros objetos do banco de dados.

Se não houver diferenças entre os ramos selecionados, você verá uma mensagem de sucesso confirmando que os esquemas estão sincronizados:

Comparação de esquemas mostrando que os esquemas estão sincronizados.

Utilize a comparação de esquemas para validação pré-merge , acompanhamento do desenvolvimento, detecção de desvios e documentação de alterações. Para ver a diferença de esquema em um fluxo de trabalho de desenvolvimento completo, consulte o tutorial: Fluxo de trabalho de desenvolvimento baseado em ramificação.

nota

A comparação de esquemas compara apenas o esquema do banco de dados (DDL), não o conteúdo dos dados. A comparação utiliza os dados mais recentes disponíveis (cabeçalho) de ambas as ramificações.

Atualizar configurações da filial

Definir como default

Cada projeto Lakebase é criado com um branch default chamado production, mas você pode designar qualquer branch como default. O branch default está isento do limite compute ativa simultaneamente, garantindo que permaneça disponível o tempo todo.

nota

Você só pode alterar a ramificação default através da interface do usuário do Lakebase. A API não permite alterar qual branch é a default.

Para definir uma ramificação como default:

Acesse a página de ramificações do seu projeto no aplicativo Lakebase.
Clique no menu ao lado da ramificação que você deseja definir como default.
Selecione "Definir como default e confirme as operações.

Definir como protegido

Os ramos protegidos ajudam a proteger ramos críticos contra modificações ou exclusões acidentais. Ramos protegidos não podem ser excluídos, redefinidos ou arquivados devido à inatividade. Projetos com ramificações protegidas e seus respectivos recursos computacionais também não podem ser excluídos.

Para definir uma ramificação como protegida:

UI
Python SDK
Java SDK
CLI
curl

Acesse "Ramos" no aplicativo Lakebase e selecione o ramo que deseja proteger.
Clique em Proteger e confirme sua seleção.

Proteger o ramo

Sua filial agora está designada como protegida, conforme indicado pelo ícone de escudo que aparece ao lado do nome da filial.

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 remover a proteção, defina is_protected=False em BranchSpec.

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 remover a proteção, defina setIsProtected(false) em BranchSpec.

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

Para remover a proteção, defina "is_protected": false no JSON.

Bash
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 remover a proteção, defina "is_protected": false no corpo da solicitação.

Para obter detalhes completos sobre ramificações protegidas, incluindo o gerenciamento de senhas para ramificações filhas, consulte Ramificações protegidas.

Atualização de expiração

Você pode definir um prazo de validade ao criar uma ramificação ou atualizá-lo posteriormente.

Ao criar uma ramificação

Acesse a página de ramificações do seu projeto no aplicativo Lakebase.
Clique em Criar ramificação , insira um nome para a ramificação (obrigatório), configure as opções da ramificação e marque a opção Expirar ramificação em para selecionar uma predefinição (1 hora, 1 dia ou 7 dias).
Clique em Criar .

Atualização do vencimento do branch

Para atualizar ou remover um carimbo de data/hora de expiração em uma ramificação existente:

UI
Python SDK
Java SDK
CLI
curl

Acesse a página de ramificações do seu projeto no aplicativo Lakebase.
Clique no No menu ao lado da filial, selecione Atualizar expiração .
Selecione uma nova data e hora ou desmarque a opção "Expirar ramo" para remover a expiração e clique em "Salvar" .

Atualização do vencimento do branch

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 remover a expiração, defina no_expiry=True em BranchSpec e inclua "spec.expiration" na máscara de atualização.

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 remover a expiração, defina setNoExpiry(true) em BranchSpec e inclua "spec.expiration" na máscara de atualização.

Bash
# 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 remover a expiração, defina "no_expiry": true no JSON.

Bash
# 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 remover a expiração, defina "no_expiry": true no corpo da solicitação.

ver expiração do ramo

Para verificar se uma ramificação possui uma data de expiração definida, acesse a página de Ramificações do seu projeto e clique na ramificação desejada. As informações sobre o prazo de validade são exibidas nos detalhes da filial.

Reset ramo a partir do pai

Você pode redefinir uma ramificação para atualizá-la instantaneamente com o esquema e os dados mais recentes de sua ramificação pai. Isso ajuda você a se recuperar de problemas, iniciar o desenvolvimento de novos recursos ou manter as diferentes ramificações do seu ambiente sincronizadas.

Cenário de exemplo

Ao trabalhar com branches, você pode se deparar com uma situação em que precisa atualizar seu branch de trabalho com os dados mais recentes do seu branch pai.

Por exemplo, digamos que você tenha dois ramos filhos staging e development bifurcados do seu ramo production . Você estava trabalhando no branch development e descobriu que ele agora está muito desatualizado com production.

Você não tem alterações de esquema em development para considerar ou preservar; você só quer uma refresh rápida dos dados. Você pode realizar uma redefinição limpa e instantânea para os dados mais recentes do servidor pai em uma única operação, evitando a complicação de criar e restaurar ramificações manualmente.

Como funciona Reset a partir do pai

Ao redefinir uma ramificação para seu pai, os dados e o esquema são completamente substituídos pelos dados e esquema mais recentes do pai.

Pontos principais:

Você só pode redefinir uma ramificação para os dados mais recentes de sua ramificação pai. É possível realizar um reset pontual baseado em um timestamp usando o recurso de restauração pontual, que é similar, mas com algumas diferenças: a restauração pontual cria um novo branch e é mais indicada para recuperação de dados do que para fluxo de trabalho de desenvolvimento.
Essa redefinição sobrescreve completamente os dados, não refresh nem merge. Quaisquer alterações locais feitas no ramo filho serão perdidas durante essa reinicialização.
As conexões existentes são interrompidas temporariamente durante a reinicialização. No entanto, os seus dados de conexão não se alteram. Todas as conexões são restabelecidas assim que a reinicialização é concluída.
Os branches raiz (como o branch production do seu projeto) não podem ser redefinidos porque não têm um branch pai para o qual redefinir.

Reset um ramo a partir de seu pai.

Para redefinir uma ramificação para seu pai:

Acesse a página de ramificações do seu projeto no aplicativo Lakebase.
Clique no No menu ao lado da ramificação que você deseja redefinir, selecione Reset do pai" .
Confirme as operações de Reset.

Reinicialização do ramo a partir do pai

nota

Se o ramo tiver ramos filhos próprios, o Reset será bloqueado. Você precisa excluir os ramos filhos primeiro antes de poder redefinir o ramo pai.

Excluir um ramo

importante

Excluir uma ramificação é uma ação permanente que não pode ser desfeita. A exclusão de um ramo também remove:

Todos os bancos de dados que pertencem ao ramo
Todas as funções associadas à filial
O recurso compute associado à filial
Todos os dados e alterações específicos dessa ramificação.

Não é possível excluir uma ramificação que possua ramificações filhas. Os ramos filhos devem ser excluídos primeiro.

Para excluir uma ramificação:

UI
Python SDK
Java SDK
CLI
curl

Acesse a página de ramificações do seu projeto no aplicativo Lakebase.
Clique no No menu ao lado da ramificação que deseja excluir, selecione Excluir ramificação .
Digite o nome da filial para confirmar a exclusão e clique em Excluir .

Python
from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

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

print("Branch deleted")

As operações de exclusão são assíncronas. O método .wait() bloqueia até que a exclusão seja concluída. Todos os recursos de ramificação (bancos de dados, funções, computação e dados) serão excluídos permanentemente.

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");

As operações de exclusão são assíncronas. O método waitForCompletion() bloqueia até que a exclusão seja concluída. Todos os recursos de ramificação (bancos de dados, funções, computação e dados) serão excluídos permanentemente.

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

Este comando retorna imediatamente. O ramo e todos os seus recursos serão excluídos permanentemente.

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

Resposta:

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

Limite de ramificações não arquivadas

O limite de branches não arquivados define quantas branches podem permanecer em um estado ativo (não arquivado) ao mesmo tempo. Quando as filiais permanecem inativas por um período prolongado, elas podem ser arquivadas automaticamente para otimizar o uso de recursos. O limite é de 10 branches não arquivadas por projeto.

Os branches arquivados podem ser desarquivados quando necessário, mas o número total de branches desarquivados ativos não pode exceder esse limite.

Importante: as ramificações protegidas e a ramificação default estão isentas de arquivamento automático e permanecem disponíveis em todos os momentos.

Entendendo os ramos​

Visão geral da filial​

Tipos e estratégias de agências​

Expiração do ramo​

Por que usar a expiração de ramificação?​

Como funciona o vencimento de branches​

Restrições de vencimento de filiais​

Período máximo de validade​

Criar e gerenciar filiais​

Criar uma ramificação​

ver ramos​

Visualizar na interface do usuário​

Obtenha uma ramificação programaticamente​

Listar programaticamente​

Comparar esquemas de ramificação​

Entenda os diferentes resultados​

Atualizar configurações da filial​

Definir como default​

Definir como protegido​

Atualização de expiração​

Ao criar uma ramificação​

Atualização do vencimento do branch​

ver expiração do ramo​

Reset ramo a partir do pai​

Cenário de exemplo​

Como funciona Reset a partir do pai​

Reset um ramo a partir de seu pai.​

Excluir um ramo​

Limite de ramificações não arquivadas​

Entendendo os ramos

Visão geral da filial

Tipos e estratégias de agências

Expiração do ramo

Por que usar a expiração de ramificação?

Como funciona o vencimento de branches

Restrições de vencimento de filiais

Período máximo de validade

Criar e gerenciar filiais

Criar uma ramificação

ver ramos

Visualizar na interface do usuário

Obtenha uma ramificação programaticamente

Listar programaticamente

Comparar esquemas de ramificação

Entenda os diferentes resultados

Atualizar configurações da filial

Definir como default

Definir como protegido

Atualização de expiração

Ao criar uma ramificação

Atualização do vencimento do branch

ver expiração do ramo

Reset ramo a partir do pai

Cenário de exemplo

Como funciona Reset a partir do pai

Reset um ramo a partir de seu pai.

Excluir um ramo

Limite de ramificações não arquivadas