Hantera projekten

Ett projekt är den översta containern för dina Lakebase-resurser, inklusive grenar, beräkningar, databaser och roller. Den här sidan förklarar hur du skapar projekt, förstår deras struktur, konfigurerar inställningar och hanterar deras livscykel.

Om du är nybörjare på Lakebase börjar du med Kom igång för att skapa ditt första projekt.

Förstå projekt

Projektstruktur

Genom att förstå Lakebase-projektstrukturen kan du organisera och hantera dina resurser effektivt. Ett projekt är den översta containern för dina databaser, grenar, beräkningar och relaterade resurser. Varje projekt innehåller inställningar för beräkningsstandarder, återställning av fönster och uppdateringar som gäller för alla grenar i projektet.

På den översta nivån innehåller ett projekt en eller flera grenar. I ett projekt kan du skapa grenar för olika miljöer, till exempel utveckling, testning, mellanlagring och produktion. Varje gren innehåller sina egna beräkningar, roller och databaser.

Project
  └── Branches (main, development, staging, etc.)
        ├── Computes (R/W compute)
        ├── Roles (Postgres roles)
        └── Databases (Postgres databases)

Grenar

Data finns i grenar. Varje Lakebase-projekt skapas med en rotgren med namnet production, som inte kan tas bort. Du kan skapa ytterligare grenar och ange en annan gren som standardgren, men rotgrenen kan inte tas bort.

Du kan skapa barngrenar från valfri gren i projektet. När du skapar en underordnad gren ärver den alla databaser, roller och data från den överordnade grenen när den skapas. Efterföljande ändringar i den överordnade grenen sprids inte automatiskt till den underordnade grenen, vilket möjliggör isolerad utveckling, testning eller experimentering.

Varje gren kan innehålla flera databaser och roller. Läs mer: Hantera grenar

Beräknar

En beräkning är en virtualiserad beräkningsresurs som innehåller vCPU och minne för att köra Postgres. När du skapar ett projekt skapas en primär läs/skrivbar beräkningsresurs för projektets standardgren. Varje gren har en enda primär R/W-beräkning. Om du vill ansluta till en databas som finns på en gren måste du ansluta via den R/W-beräkning som är associerad med grenen.

Förutom den primära R/W-beräkningen kan du lägga till en eller flera läsreplika-beräkningar till valfri gren. Med läsrepliker kan du avlasta läslast från ditt primära beräkningssystem för användningsfall som horisontell lässkalning, analys- och rapporteringsfrågeställningar samt lästillgång för användare eller applikationer. Läs mer: Hantera beräkningar, Läsrepliker

Roller

Roller är Postgres-roller. En roll krävs för att skapa och komma åt en databas. En roll tillhör en gren. När du skapar ett projekt skapas en Postgres-roll automatiskt för din Databricks-identitet (till exempel user@databricks.com), som är ägare till standarddatabasen databricks_postgres . Alla roller som skapas i Lakebase-användargränssnittet skapas med databricks_superuser behörigheter. Det finns en gräns på 500 roller per gren. Läs mer: Hantera roller

Databaser

En databas är en container för SQL-objekt som scheman, tabeller, vyer, funktioner och index. I Lakebase tillhör en databas en gren. Standardgrenen för projektet skapas med en databas med namnet databricks_postgres. Det finns en gräns på 500 databaser per gren. Läs mer: Hantera databaser

Scheman

Alla databaser i Lakebase skapas med ett public schema, vilket är standardbeteendet för alla Postgres-standardinstanser. SQL-objekt skapas som standard i public schemat.

Projektsbegränsningar

Lakebase Postgres tillämpar följande gränser för projekt:

Samtidig aktiv beräkningsgräns

Den samtidiga aktiva beräkningsgränsen begränsar hur många beräkningar som kan köras samtidigt för att förhindra resursöverbelastning. Den här gränsen skyddar mot oavsiktliga resurstoppar, till exempel att starta många beräkningsslutpunkter samtidigt. Standardgränsen är 20 samtidiga aktiva beräkningar per projekt.

Viktigt: Standardgrenen är undantagen från den här gränsen, vilket säkerställer att den alltid är tillgänglig.

När du överskrider gränsen förblir ytterligare beräkningar utöver gränsen pausade och du ser ett fel när du försöker ansluta till dem. För att lösa detta:

1. Pausa andra aktiva beräkningar och försök igen.
2. Om du stöter på det här felet ofta kontaktar du Databricks-supporten för att begära en gränsökning.

Databaslagringskvot

Varje gren har en lagringskvot på 16 TB för databasen. Det här är en driftskvot snarare än en arkitekturgräns eftersom data finns i molnobjektlagring i stället för på en etablerad lokal disk.

När en databas når sin kvot sjunker skrivprestandan, men du kan fortfarande släppa eller ta bort data för att frigöra utrymme. Kontakta Databricks Support om du behöver en större kvot.

Endast dina faktiska data (tabeller och index, som rapporterats av Postgres) räknas mot kvoten. Historik som bevaras för återställning till viss tidpunkt gör inte det i alla situationer.

Regiontillgänglighet

Regioner som stöds:

• eastus (USA, östra)
• eastus2 (Östra USA 2)
• centralus (USA, centrala)
• northcentralus (Norra centrala USA)
• southcentralus (Södra centrala USA)
• westus (Västra USA)
• westus2 (USA, västra 2)
• canadacentral (Kanada Centrala)
• brazilsouth (Södra Brasilien)
• northeurope (Europa, norra)
• uksouth (Storbritannien, södra)
• westeurope (Europa, västra)
• francecentral (Frankrike Central)
• germanywestcentral (Tyskland Västcentral)
• australiaeast (Australien, östra)
• centralindia (Centrala Indien)
• southeastasia (Sydostasien)
• eastasia (Östasien)

Ditt Lakebase-projekt skapas i din Databricks-arbetsyteregion.

Stöd för Postgres-version

Lakebase Postgres Autoscaling stöder Postgres 16, Postgres 17 och Postgres 18. Postgres 17 är standardversionen. Om du vill använda Postgres 18 väljer du det när du skapar ett nytt projekt.

Skapa och hantera projekt

Skapa ett projekt

Du kan skapa flera projekt i Lakebase Postgres för att hålla program eller kunder helt isolerade, vilket säkerställer en ren uppdelning av data och resurser.

Så här skapar du ett projekt:

Användargränssnitt (UI)

1. Klicka på appväxlaren uppe i högra hörnet för att öppna Lakebase-appen.
2. Klicka på Nytt projekt.
3. Konfigurera dina projektinställningar:
   • Visningsnamn: Ange ett namn för projektet. Du kan använda alla tecken, inklusive blanksteg och specialtecken. Vanliga namngivningsmönster är namngivning efter programmet (till exempel My Analytics App) eller kunden eller klientorganisationen som projektet betjänar (till exempel Acme Corp DB). Ett resursnamn härleds automatiskt från visningsnamnet och används för att identifiera projektet i API- och SDK-anrop. Dialogrutan visar det resulterande resursnamnet (till exempel projects/my-analytics-app) så att du kan verifiera det innan du skapar projektet.
   • Postgres-version: Välj den Postgres-version som du vill använda.
   • Serverlös användningsprincip (valfritt): Välj en serverlös användningsprincip för att tilldela serverlösa beräkningskostnader till en specifik princip. Se Serverlösa användningsprinciper.

Dialogrutan Skapa projekt visar projektkonfigurationsalternativen.

Region för ditt Lakebase-projekt är inställt på din Databricks-arbetsyteregion och kan inte ändras.

Python SDK

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Project, ProjectSpec

# Initialize the Workspace client
w = WorkspaceClient()

# Create a project with a custom project ID
operation = w.postgres.create_project(
    project=Project(
        spec=ProjectSpec(
            display_name="My Application",
            pg_version=17,
            budget_policy_id="<policy-id>"
        )
    ),
    project_id="my-app"
)

# Wait for operation to complete
result = operation.wait()
print(f"Created project: {result.name}")
print(f"Display name: {result.status.display_name}")
print(f"Postgres version: {result.status.pg_version}")

Java SDK

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

// Initialize the Workspace client
WorkspaceClient w = new WorkspaceClient();

// Create a project with a custom project ID
CreateProjectOperation operation = w.postgres().createProject(
    new CreateProjectRequest()
        .setProjectId("my-app")
        .setProject(new Project()
            .setSpec(new ProjectSpec()
                .setDisplayName("My Application")
                .setPgVersion(17L)))
);

// Wait for operation to complete
Project result = operation.waitForCompletion();
System.out.println("Created project: " + result.getName());
System.out.println("Display name: " + result.getStatus().getDisplayName());
System.out.println("Postgres version: " + result.getStatus().getPgVersion());

Kommandoradsgränssnitt (CLI)

# Create a project with a custom project ID
databricks postgres create-project my-app \
  --json '{
    "spec": {
      "display_name": "My Application",
      "pg_version": 17,
      "budget_policy_id": "<policy-id>"
    }
  }'

lockig

Skapa ett projekt med ett anpassat projekt-ID. project_id Anges som en frågeparameter och blir en del av projektets resursnamn (till exempel projects/my-app).

curl -X POST "$WORKSPACE/api/2.0/postgres/projects?project_id=my-app" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "display_name": "My Application",
      "pg_version": 17,
      "budget_policy_id": "<policy-id>"
    }
  }' | jq

Det här är en tidskrävande åtgärd. Svaret innehåller ett åtgärdsnamn som du kan använda för att kontrollera statusen. Åtgärden slutförs vanligtvis inom några sekunder.

Parametern project_id krävs.

Ett nytt projekt innehåller följande resurser som standard:

• En enda production gren (standardgrenen)

• En enda primär skrivbaserad beräkning som är associerad med grenen med följande standardinställningar:

  Filial	Beräkningsenheter (CU)	HA	Autoscaling	Skalning till noll
  production	8 - 16 CU	Inaktiverad	Aktiverad	Aktiverad (24h)

  När du skapar ett projekt skapas grenen production med en beräkning som har skalning till noll aktiverat som standard med en tidsgräns på 24 timmar för inaktivitet. Du kan justera tidsgränsen eller inaktivera skalning till noll för den här beräkningsresursen om det behövs.

• En Postgres-databas (med namnet databricks_postgres)

• En Postgres-roll för din Databricks-identitet (till exempel user@databricks.com)

Information om hur du ändrar beräkningsinställningar för ett befintligt projekt finns i Konfigurera projektinställningar. Information om hur du ändrar standardinställningarna för beräkning för nya projekt finns i Beräkningsstandarder i Konfigurera projektinställningar.

Hämta projektinformation

Hämta information för ett visst projekt.

Användargränssnitt (UI)

1. Klicka på appväxlaren uppe i högra hörnet för att öppna Lakebase-appen.
2. Välj ditt projekt i projektlistan för att visa dess information.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Get project details
project = w.postgres.get_project(name="projects/my-project")

print(f"Project: {project.name}")
print(f"Display name: {project.status.display_name}")
print(f"Postgres version: {project.status.pg_version}")

Java SDK

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

WorkspaceClient w = new WorkspaceClient();

// Get project details
Project project = w.postgres().getProject("projects/my-project");

System.out.println("Project: " + project.getName());
System.out.println("Display name: " + project.getStatus().getDisplayName());
System.out.println("Postgres version: " + project.getStatus().getPgVersion());

Kommandoradsgränssnitt (CLI)

# Get project details
databricks postgres get-project projects/my-project

lockig

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

Svaret omfattar:

• name: Resursnamn (projects/my-project)
• status: Projekt-konfiguration och nuvarande tillstånd (display_name, pg_version osv.)

Obs! Fältet spec är inte ifyllt för GET åtgärder. Alla resursegenskaper returneras i fältet status .

Lista projekten

Visa en lista över alla projekt på din arbetsyta.

Användargränssnitt (UI)

1. Klicka på appväxlaren uppe i högra hörnet för att öppna Lakebase-appen.
2. Projektlistan visar alla projekt som du har åtkomst till.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# List all projects
projects = w.postgres.list_projects()

for project in projects:
    print(f"Project: {project.name}")
    print(f"  Display name: {project.status.display_name}")
    print(f"  Postgres version: {project.status.pg_version}")

Java SDK

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

WorkspaceClient w = new WorkspaceClient();

// List all projects
for (Project project : w.postgres().listProjects(new ListProjectsRequest())) {
    System.out.println("Project: " + project.getName());
    System.out.println("  Display name: " + project.getStatus().getDisplayName());
    System.out.println("  Postgres version: " + project.getStatus().getPgVersion());
}

Kommandoradsgränssnitt (CLI)

# List all projects
databricks postgres list-projects

lockig

curl -X GET "$WORKSPACE/api/2.0/postgres/projects" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Svarsformat:

{
  "projects": [
    {
      "name": "projects/my-project",
      "status": {
        "display_name": "My Project",
        "pg_version": 17
      }
    }
  ]
}

Konfigurera projektinställningar

När du har skapat ett projekt kan du ändra olika inställningar från projektinstrumentpanelen genom att gå till Inställningar:

Allmänna inställningar

Sidan Allmänna inställningar visar följande fält:

• Visningsnamn: Det redigerbara visningsnamnet för projektet.
• Resursnamn: Skrivskyddad. Den fullständiga resurssökvägen för projektet (format: projects/{project_id}). Använd det här värdet i API- och SDK-anrop för att identifiera projektet.
• UID: Endast läsbar. Den systemgenererade unika identifieraren för projektet.
• Serverlös användningsprincip: Associera en serverlös användningsprincip med ditt projekt för att tilldela serverlösa beräkningskostnader till en specifik princip. Se Serverlösa användningsprinciper.
• Anpassade taggar: Lägg till nyckel/värde-taggar i projektet. Taggar loggas i kontots fakturerbara användningsposter (system.billing.usage) och kan användas för att spåra kostnader efter team, projekt eller kostnadsställe. Se Anpassade taggar. När du uppdaterar anpassade taggar med hjälp av API:et eller CLI ersätter den nya listan alla befintliga taggar.

Användargränssnitt (UI)

Python SDK

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Project, ProjectSpec, ProjectCustomTag, FieldMask

w = WorkspaceClient()

# Update project display name
w.postgres.update_project(
    name="projects/my-project",
    update_mask=FieldMask(field_mask=["spec.display_name"]),
    project=Project(spec=ProjectSpec(display_name="My Updated Project Name"))
).wait()

# Update serverless usage policy
w.postgres.update_project(
    name="projects/my-project",
    update_mask=FieldMask(field_mask=["spec.budget_policy_id"]),
    project=Project(spec=ProjectSpec(budget_policy_id="<policy-id>"))
).wait()

# Update custom tags (replaces all existing tags)
w.postgres.update_project(
    name="projects/my-project",
    update_mask=FieldMask(field_mask=["spec.custom_tags"]),
    project=Project(spec=ProjectSpec(custom_tags=[
        ProjectCustomTag(key="team", value="data-eng"),
        ProjectCustomTag(key="cost-center", value="1234")
    ]))
).wait()

Kommandoradsgränssnitt (CLI)

# Update project display name
databricks postgres update-project projects/my-project spec.display_name \
  --json '{
    "spec": {
      "display_name": "My Updated Project Name"
    }
  }'

# Update serverless usage policy
databricks postgres update-project projects/my-project spec.budget_policy_id \
  --json '{
    "spec": {
      "budget_policy_id": "<policy-id>"
    }
  }'

# Update custom tags
databricks postgres update-project projects/my-project spec.custom_tags \
  --json '{
    "spec": {
      "custom_tags": [
        {"key": "team", "value": "data-eng"},
        {"key": "cost-center", "value": "1234"}
      ]
    }
  }'

lockig

# Update project display name
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project?update_mask=spec.display_name" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "display_name": "My Updated Project Name"
    }
  }' | jq

# Update serverless usage policy
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project?update_mask=spec.budget_policy_id" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "budget_policy_id": "<policy-id>"
    }
  }' | jq

# Update custom tags
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project?update_mask=spec.custom_tags" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "custom_tags": [
        {"key": "team", "value": "data-eng"},
        {"key": "cost-center", "value": "1234"}
      ]
    }
  }' | jq

Det här är tidskrävande åtgärder. Svaret innehåller ett åtgärdsnamn som du kan använda för att kontrollera statusen.

Standardvärden för beräkning

Dessa standardvärden används som inledande inställningar för alla primära eller lästa replikberäkningar som du skapar. Om du ändrar dessa standardvärden ändras inte inställningarna för befintliga beräkningar.

Standardvärden:

• Beräkningsstorlek: 2 ↔ 4 CU (autoskalningsintervall; ~4–8 GB RAM-minne)
• Skala till noll: Aktiverad som standard – Pausa beräkningen efter att en period av inaktivitet har markerats, med Pausa efter 24 timmar valt

Klicka på Ändra standardvärden för att öppna dialogrutan och ändra dessa värden.

Lakebase Postgres stöder beräkningsstorlekar från 0,5 CU till 112 CU. Automatisk skalning är tillgänglig för beräkningsresurser upp till 64 CU (0,5, därefter i heltalssteg: 1, 2, 3... 64). Större beräkningsresurser med fast storlek finns tillgängliga upp till 112 CU. Varje beräkningsenhet (CU) tillhandahåller 2 GB RAM-minne.

Representativa storlekar:

• Om du vill aktivera autoskalning anger du ett beräkningsstorleksintervall med skjutreglaget. Autoskalning justerar dynamiskt beräkningsresurser baserat på arbetsbelastningens behov. Läs mer: Autoskalning
• Justera inställningen skala till noll för att öka eller minska mängden inaktiv beräkningstid innan en beräkning avbryts (från 60 sekunder upp till 7 dagar när den är aktiverad). Du kan också inaktivera skalning till noll för en alltid aktiv beräkning. Läs mer: Skala till noll

Historikfönster

Konfigurera längden på historikfönstret för projektet. Som standard behåller Lakebase en historik över ändringar för rotgrenar i projektet, vilket möjliggör punkt-i-tid-återställning för att återställa förlorade data, fråga data från en viss tidpunkt för att undersöka dataproblem och förgrening från tidigare tillstånd för utvecklingsarbetsflöden.

Du kan ange historikfönstret från 2 dagar upp till 30 dagar, med standardvärdet 7 dagar. Tänk på följande:

• Om du utökar historikfönstret ökar lagringsutrymmet
• Inställningen för historikfönstret påverkar alla grenar i projektet

Project behörigheter

Kontrollera vem som kan komma åt och hantera ditt Lakebase-projekt genom att ge behörighet till Azure Databricks identiteter, grupper och tjänstens huvudnamn. Project behörigheter avgör vilka åtgärder användarna kan utföra inom project, till exempel att skapa grenar, hantera beräkningar och visa anslutningsinformation.

Behörighetstyper:

• KAN SKAPA: Visa och skapa projektresurser
• KAN ANVÄNDAS: Visa och använda projektresurser (lista, visa, ansluta och utföra vissa grenåtgärder) utan att skapa eller ta bort projekt eller grenar
• KAN HANTERA: Fullständig kontroll över projektkonfiguration och resurser

Standardbehörigheter:

När du skapar ett projekt tilldelas följande behörigheter automatiskt:

• Projektägare (användaren som skapade projekt): KAN HANTERA (fullständig kontroll)
• Arbetsyteanvändare: KAN SKAPA (kan visa och skapa projekt)
• Arbetsyteadministratörer: KAN HANTERA (fullständig kontroll)

Information om hur du beviljar åtkomst till andra användare finns i Hantera projektbehörigheter.

Uppdateringar

För att hålla dina Lakebase-beräknings- och Postgres-instanser uppdaterade tillämpar Lakebase automatiskt schemalagda uppdateringar som inkluderar uppgraderingar av delversioner av Postgres, säkerhetskorrigeringar och plattformsfunktioner. Uppdateringar tillämpas på beräkningen i projektet och kräver en kort omstart av beräkningen som tar några sekunder.

Uppdateringar tillämpas automatiskt, men du kan ange en önskad dag och tid för uppdateringar. Omstarter sker inom det valda tidsfönstret.

Detaljerad information om uppdateringar finns i Hantera uppdateringar.

Ta bort ett projekt

När du tar bort ett projekt går det in i ett mjukt borttaget tillstånd som standard och behålls i 7 dagar innan det tas bort permanent. Under det här fönstret kan du återställa projektet och återställa alla dess data. Se Återställa ett borttaget projekt. Information om hur du hoppar över kvarhållningsperioden och tar bort projektet direkt finns i Ta bort ett projekt permanent.

Innan du tar bort

Databricks rekommenderar att du tar bort alla associerade Unity-katalogkataloger och synkroniserade tabeller innan du tar bort projektet. Annars resulterar försök att visa kataloger eller köra SQL-frågor som refererar till dem i fel.

Om du inte äger tabellerna eller katalogerna måste du omtilldela ägarskapet till dig själv innan du tar bort dem.

Ta bort ett projekt

Så här tar du bort ett projekt:

Användargränssnitt (UI)

1. Gå till projektets inställningar i Lakebase-appen.
2. I avsnittet Ta bort projekt klickar du på Ta bort och anger projektnamnet för att bekräfta borttagningen.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Delete a project
operation = w.postgres.delete_project(name="projects/my-project")

print(f"Delete operation started: {operation.name()}")

Det här är en tidskrävande åtgärd. Projektet och alla dess resurser (grenar, slutpunkter, databaser, roller, data) tas bort.

Java SDK

import com.databricks.sdk.WorkspaceClient;

WorkspaceClient w = new WorkspaceClient();

// Delete a project
w.postgres().deleteProject("projects/my-project");

System.out.println("Delete operation started");

Det här är en tidskrävande åtgärd. Projektet och alla dess resurser (grenar, slutpunkter, databaser, roller, data) tas bort.

Kommandoradsgränssnitt (CLI)

# Delete a project
databricks postgres delete-project projects/my-project

Det här kommandot returnerar omedelbart. Projektet och alla dess resurser tas bort.

lockig

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

Det här är en tidskrävande åtgärd. Svaret innehåller ett åtgärdsnamn som du kan använda för att kontrollera borttagningsstatusen.

Ta bort ett projekt permanent

Ta bort ett Lakebase-projekt permanent omedelbart utan att vänta på att kvarhållningsperioden på 7 dagar för mjuk borttagning upphör att gälla:

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

operation = w.postgres.delete_project(name="projects/my-project", purge=True)
operation.wait()

Java SDK

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

WorkspaceClient w = new WorkspaceClient();

w.postgres().deleteProject(
    new DeleteProjectRequest()
        .setName("projects/my-project")
        .setPurge(true)
).waitForCompletion();

Kommandoradsgränssnitt (CLI)

databricks postgres delete-project projects/my-project --purge

lockig

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

Återställa ett borttaget projekt

När du tar bort ett Lakebase-projekt går det in i ett mjukt borttaget tillstånd och behålls i 7 dagar innan det tas bort permanent. Under det här fönstret kan du återställa projektet och återställa alla dess data.

Vad återställs

När du återställer ett mjukt borttaget projekt återställs följande:

• Alla grenar och deras data
• Alla Postgres-databaser och roller
• Alla beräkningsslutpunkter och deras konfigurationer
• Projektinställningar, inklusive standardinställningar för beräkning, inställningar för att återställa fönster och inställningar för uppdateringar
• Projektbehörigheter

Hitta mjukt borttagna projekt

Om du vill visa en lista över alla projekt, inklusive mjukt borttagna, använder du parametern show_deleted . Det här är användbart för att hitta resursnamnet för ett projekt som du vill återställa.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

for project in w.postgres.list_projects(show_deleted=True):
    print(f"Project: {project.name}")
    print(f"  Display name: {project.status.display_name}")
    if project.delete_time:
        print(f"  Deleted: {project.delete_time}")
        print(f"  Purge time: {project.purge_time}")

Kommandoradsgränssnitt (CLI)

databricks postgres list-projects --show-deleted

lockig

curl -X GET "$WORKSPACE/api/2.0/postgres/projects?show_deleted=true" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Återställa ett projekt

Så här återställer du ett mjukt borttaget Lakebase-projekt:

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

operation = w.postgres.undelete_project(name="projects/my-project")
operation.wait()

Java SDK

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

WorkspaceClient w = new WorkspaceClient();

w.postgres().undeleteProject(
    new UndeleteProjectRequest().setName("projects/my-project")
).waitForCompletion();

Kommandoradsgränssnitt (CLI)

databricks postgres undelete-project projects/my-project

lockig

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