Správa projektů

Projekt je kontejner nejvyšší úrovně pro prostředky Lakebase, včetně větví, výpočtů, databází a rolí. Tato stránka vysvětluje, jak vytvářet projekty, porozumět jejich struktuře, konfigurovat nastavení a spravovat jejich životní cyklus.

Pokud s Lakebase teprve začínáte, začněte tím, že začnete vytvářet svůj první projekt.

Porozumění projektům

Struktura projektu

Pochopení struktury projektu Lakebase vám pomůže efektivně organizovat a spravovat prostředky. Projekt je kontejner nejvyšší úrovně pro vaše databáze, větve, výpočty a související prostředky. Každý projekt zahrnuje nastavení výchozích hodnot výpočetních prostředků, obnovení oken a aktualizací, které platí pro všechny větve v projektu.

Na nejvyšší úrovni projekt obsahuje jednu nebo více větví. V rámci projektu můžete vytvářet větve pro různá prostředí, jako je vývoj, testování, příprava a produkce. Každá větev obsahuje vlastní výpočetní prostředky, role a databáze.

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

Větve

Data se nacházejí ve větvích. Každý projekt Lakebase je vytvořen s kořenovou větví nazvanou production, kterou nelze odstranit. I když můžete vytvořit další větve a určit jinou větev jako výchozí větev, kořenovou větev nelze odstranit.

Podřízené větve můžete vytvářet z libovolné větve v projektu. Když vytvoříte podřízenou větev, dědí všechny databáze, role a data z nadřazené větve v okamžiku vytvoření. Následné změny v nadřazené větvi se automaticky nešíří do podřízené větve, což umožňuje izolovaný vývoj, testování nebo experimentování.

Každá větev může obsahovat více databází a rolí. Další informace: Správa větví

Vypočítá

Výpočetní jednotka je virtualizovaný výpočetní zdroj, který zahrnuje vCPU a paměť pro spuštění PostgreSQL. Při vytváření projektu se pro výchozí větev projektu vytvoří primární výpočetní prostředí R/W (čtení i zápis). Každá větev má jeden primární R/W výpočetní prvek. Pokud se chcete připojit k databázi, která se nachází ve větvi, musíte se připojit pomocí výpočetních prostředků R/W přidružených k této větvi.

Kromě primárního výpočetního prostředí R/W můžete do libovolné větve přidat jednu nebo více výpočetních jednotek jako repliky pro čtení (pouze ke čtení). Repliky pro čtení umožňují přesměrovat úlohy jen pro čtení z primárního výpočetního prostředí pro případy použití, jako jsou horizontální škálování čtení, dotazy analýzy a generování sestav a přístup jen pro čtení pro uživatele nebo aplikace. Další informace: Správa výpočetních prostředků, replik pro čtení

Role

Role jsou rolemi Postgres. K vytvoření a přístupu k databázi se vyžaduje role. Role náleží k větvi. Při vytváření projektu se automaticky vytvoří role Postgres pro vaši identitu Databricks (například user@databricks.com), což je vlastník výchozí databricks_postgres databáze. Každá role vytvořená v uživatelském rozhraní Lakebase se vytvoří s oprávněními databricks_superuser . Pro každou větev platí limit 500 rolí. Další informace: Správa rolí

Databáze

Databáze je kontejner pro objekty SQL, jako jsou schémata, tabulky, zobrazení, funkce a indexy. V Lakebase patří databáze do větve. Výchozí větev vašeho projektu je vytvořena s databází nazvanou databricks_postgres. Pro každou větev platí limit 500 databází. Další informace: Správa databází

Schémata

Všechny databáze v Lakebase se vytvářejí se schématem public , což je výchozí chování pro všechny standardní instance Postgres. Objekty SQL se ve výchozím nastavení vytvářejí ve schématu public .

Limity projektu

Lakebase Postgres vynucuje pro projekty následující omezení:

Resource Omezení
Maximální počet souběžně aktivních výpočetních prostředků 20
Maximální počet čtecích replik na jednu větev 6
Maximální počet větví na projekt 500
Maximální počet rolí Postgres na větev 500
Maximální počet databází Postgres na větev 500
Kvóta úložiště databáze (na větev) 16 terabajtů
Maximální počet projektů na pracovní prostor 1 000
Maximální počet chráněných větví 1
Maximální počet kořenových větví 3
Maximální počet nearchivovaných větví 10
Maximální počet ručních snímků 10
Maximální doba uchovávání historie 30 dní
Minimální škálování na nulu 60 sekund
Maximální doba škálování na nulu 7 dní

`Limit souběžně aktivních výpočetních prostředků`

Souběžně aktivní limit výpočetních prostředků omezuje počet výpočetních prostředků, které se můžou spustit současně, aby se zabránilo vyčerpání prostředků. Tento limit chrání před náhodnými nárůsty prostředků, například spuštěním mnoha výpočetních koncových bodů najednou. Výchozí limit je 20 současně aktivních výpočtů na jeden projekt.

Důležité: Výchozí větev je z tohoto limitu vyloučená a zajišťuje, aby byla stále dostupná.

Když limit překročíte, zůstanou další výpočetní prostředky nad limit pozastavené a při pokusu o připojení k nim se zobrazí chyba. Řešení je následující:

  1. Pozastavte ostatní aktivní výpočetní prostředky a zkuste to znovu.
  2. Pokud k této chybě dochází často, obraťte se na podporu Databricks a požádejte o navýšení limitu.

Poznámka:

Výpočty s povoleným škálováním na nulu se automaticky pozastaví po určité době nečinnosti, což vám pomůže zůstat v rámci souběžně aktivního limitu výpočetních prostředků.

Kvóta úložiště databáze

Každá větev má kvótu úložiště databáze o velikosti 16 TB. Jedná se o provozní kvótu místo omezení architektury, protože data se nacházejí v cloudovém úložišti objektů místo na zřízeném místním disku.

Když databáze dosáhne své kvóty, výkon zápisu klesne, ale data můžete přesto odstranit nebo odstranit, abyste uvolnili místo. Pokud potřebujete větší kvótu, obraťte se na podporu Databricks.

Do kvóty se započítávají pouze vaše skutečná data (tabulky a indexy, jak hlásí Postgres). Historie se neuchovává pro obnovení k určitému bodu v čase.

Dostupnost oblastí

Podporované oblasti:

  • eastus (USA – východ)
  • eastus2 (Východní USA 2)
  • centralus (Střední USA)
  • southcentralus (středojih USA)
  • westus (USA – západ)
  • westus2 (USA – západ 2)
  • canadacentral (Kanada – centrální)
  • brazilsouth (Brazílie – jih)
  • northeurope (Severní Evropa)
  • uksouth (Velká Británie – jih)
  • westeurope (Západní Evropa)
  • australiaeast (Austrálie – východ)
  • centralindia (Střední Indie)
  • southeastasia (Jihovýchodní Asie)

Projekt Lakebase se vytvoří v oblasti pracovního prostoru Databricks.

Podpora verzí Postgres

Automatické škálování Lakebase Postgres podporuje Postgres 16, Postgres 17 a Postgres 18. Postgres 17 je výchozí verze. Pokud chcete použít Postgres 18, vyberte ho při vytváření nového projektu.

Vytváření a správa projektů

Vytvoření projektu

V Lakebase Postgres můžete vytvořit více projektů, abyste zajistili úplné oddělení aplikací nebo zákazníků a zajistili tak čisté oddělení dat a prostředků.

Vytvoření projektu:

uživatelské rozhraní

  1. Kliknutím na přepínač aplikací v pravém horním rohu otevřete aplikaci Lakebase.
  2. Klikněte na Nový projekt.
  3. Konfigurace nastavení projektu:
    • Zobrazovaný název: Zadejte název projektu. Můžete použít libovolné znaky, včetně mezer a speciálních znaků. Mezi běžné vzory pojmenování patří pojmenování podle aplikace (například My Analytics App) nebo podle zákazníka či nájemce, kterému projekt slouží (například Acme Corp DB). Název prostředku se odvozuje z vašeho zobrazovaného názvu automaticky a slouží k identifikaci projektu ve voláních rozhraní API a sady SDK. V dialogovém okně se zobrazí výsledný název zdroje (například projects/my-analytics-app), abyste ho mohli před vytvořením projektu ověřit.
    • Verze Postgres: Vyberte verzi Postgres, kterou chcete použít.
    • Bezserverové zásady použití (volitelné): Vyberte zásadu bezserverového využití, která přiřazují náklady na výpočetní prostředky bez serveru konkrétním zásadám. Viz Zásady použití bez serveru.

Dialogové okno Vytvořit projekt zobrazuje možnosti konfigurace projektu.

Dialogové okno Vytvořit projekt

Oblast projektu Lakebase je nastavená na oblast pracovního prostoru Databricks a nelze ji upravit.

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

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

kroucení

Vytvořte projekt s vlastním ID projektu. project_id je zadán jako parametr v dotazu a stává se součástí názvu zdroje projektu (například 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

Jedná se o dlouhotrvající operaci. Odpověď obsahuje název operace, kterou můžete použít ke kontrole stavu. Operace se obvykle dokončí během několika sekund.

Je vyžadován parametr project_id.

Poznámka:

Pokud vytváříte projekt se stejným ID jako nedávno odstraněný projekt, mějte na paměti, že odstraněná ID projektu jsou vyhrazena po dobu 7 dnů. Pokud chcete ID okamžitě znovu použít, nejprve trvale odstraňte původní projekt.

Nový projekt ve výchozím nastavení obsahuje následující zdroje:

  • Jedna production větev (výchozí větev)

  • Jeden primární výpočetní výkon pro čtení i zápis přidružený k větvi s následujícím výchozím nastavením:

    Branch Výpočetní jednotky (CU) vysoká dostupnost Autoscaling Škálování na nulu
    production 8 - 16 CU Disabled Enabled Povoleno (24h)

    Když vytvoříte projekt, vytvoří se větev production s výpočetní instancí, která má ve výchozím nastavení povolené škálování na nulu s 24hodinovým časovým limitem nečinnosti. V případě potřeby můžete časový limit upravit nebo u tohoto výpočetního prostředí vypnout škálování na nulu.

  • Databáze Postgres (pojmenovaná databricks_postgres)

  • Role Postgres pro vaši identitu Databricks (například user@databricks.com)

Pokud chcete změnit nastavení výpočetních prostředků pro existující projekt, přečtěte si téma Konfigurace nastavení projektu. Pokud chcete upravit výchozí nastavení výpočetních prostředků pro nové projekty, přečtěte si téma Výchozí nastavení výpočetních prostředků v části Konfigurace nastavení projektu.

Získání podrobností o projektu

Načtěte podrobnosti pro konkrétní projekt.

uživatelské rozhraní

  1. Kliknutím na přepínač aplikací v pravém horním rohu otevřete aplikaci Lakebase.
  2. Výběrem projektu ze seznamu projektů zobrazíte jeho podrobnosti.

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

CLI

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

kroucení

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

Odpověď zahrnuje:

  • name: Název prostředku (projects/my-project)
  • status: konfigurace projektu a aktuální stav (display_name, pg_version atd.)

Poznámka: Pole spec není vyplněno pro GET operace. V poli status se vrátí všechny vlastnosti zdroje.

Výpis projektů

Zobrazí seznam všech projektů v pracovním prostoru.

uživatelské rozhraní

  1. Kliknutím na přepínač aplikací v pravém horním rohu otevřete aplikaci Lakebase.
  2. V seznamu projektů se zobrazí všechny projekty, ke kterým máte přístup.

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

CLI

# List all projects
databricks postgres list-projects

kroucení

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

Formát odpovědi:

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

Konfigurace nastavení projektu

Po vytvoření projektu můžete změnit různá nastavení z řídicího panelu projektu tak, že přejdete na Nastavení:

Obecná nastavení

Na stránce obecné nastavení se zobrazí následující pole:

  • Zobrazovaný název: Upravitelný zobrazovaný název projektu.
  • Název prostředku: Jen pro čtení. Úplná cesta ke zdrojovému souboru pro váš projekt (formát: projects/{project_id}). Tuto hodnotu použijte ve voláních rozhraní API a sady SDK k identifikaci projektu.
  • UID: Jen pro čtení. Jedinečný identifikátor vygenerovaný systémem pro váš projekt.
  • Zásady použití bez serveru: Přidružte k projektu zásady bezserverového využití, které přiřazují náklady na výpočetní prostředky bez serveru konkrétním zásadám. Viz Zásady použití bez serveru.
  • Vlastní značky: Přidejte do projektu značky typu klíč-hodnota. Značky se zaznamenávají do fakturovatelných záznamů o využití vašeho účtu (system.billing.usage) a dají se použít ke sledování nákladů podle týmu, projektu nebo nákladového střediska. Viz Vlastní značky. Když aktualizujete vlastní značky pomocí rozhraní API nebo rozhraní příkazového řádku, nahradí nový seznam všechny existující značky.
uživatelské rozhraní

Nastavení názvu a ID projektu

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()
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"}
      ]
    }
  }'
kroucení
# 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

Jedná se o dlouhotrvající operace. Odpověď obsahuje název operace, kterou můžete použít ke kontrole stavu.

Výchozí nastavení výpočtů

Tyto výchozí nastavení se použijí jako počáteční nastavení pro jakékoli primární výpočetní jednotky nebo výpočetní jednotky pro čtení, které vytvoříte. Úprava těchto výchozích hodnot nemění nastavení existujících výpočetních prostředků.

Výchozí hodnoty:

  • Velikost výpočetních prostředků: 2 ↔ 4 CU (rozsah automatického škálování; přibližně 4–8 GB PAMĚTI RAM)
  • Škálování na nulu: Povoleno ve výchozím nastavení – Pozastavení výpočetních prostředků po zaškrtnuté době nečinnosti s vybranou možností Pozastavit po 24 hodinách

Kliknutím na Změnit výchozí hodnoty otevřete dialogové okno a změňte tyto hodnoty.

Poznámka:

Pokud chcete upravit nastavení existujícího výpočetního prostředí, přečtěte si téma Správa výpočetních prostředků.

Lakebase Postgres podporuje výpočetní velikosti od 0,5 CU do 112 CU. Automatické škálování je k dispozici pro výpočty až 64 CU (0,5, pak celé číslo: 1, 2, 3... 64). Větší výpočetní prostředky s pevnou velikostí jsou k dispozici až do 112 CU. Každá výpočetní jednotka (CU) poskytuje 2 GB paměti RAM.

Poznámka:

Lakebase Zřízeno vs. Automatické škálování: Ve zřízeném Lakebase má každá výpočetní jednotka přiděleno přibližně 16 GB paměti RAM. V případě automatického škálování LakeBase přidělí každá CU 2 GB paměti RAM. Tato změna poskytuje podrobnější možnosti škálování a kontrolu nákladů.

Reprezentativní velikosti:

Výpočetní jednotky paměť RAM
0,5 CU 1 GB
1 CU 2 GB
4 CU 8 GB
8 výpočetních jednotek (CU) 16 GB
16 výpočetních jednotek (CU) 32 GB
32 výpočetních jednotek (CU) 64 GB
64 jednotek CU 128 GB
112 výpočetních jednotek (CU) 224 GB
  • Chcete-li povolit automatické škálování, nastavte pomocí posuvníku rozsah velikosti výpočetního výkonu. Automatické škálování dynamicky upravuje výpočetní prostředky na základě poptávky po úlohách. Další informace: Automatické škálování
  • Upravte nastavení škálování na nulu, aby se zvýšilo nebo snížilo množství neaktivního výpočetního času před pozastavením výpočetních prostředků (od 60 sekund až po 7 dnů, pokud je tato možnost povolená). U vždy aktivních výpočetních prostředků můžete také zakázat škálování na nulu . Další informace: Škálování na nulu

Výchozí nastavení výpočetních prostředků

Okno Historie

Nakonfigurujte délku okna historie projektu. Lakebase ve výchozím nastavení uchovává historii změn kořenových větví v projektu, což umožňuje obnovení ztracených dat k určitému časovému bodu, dotazování na data v konkrétním časovém okamžiku pro zkoumání problémů s daty a větvení z minulých stavů pro vývojové pracovní postupy.

Okno historie můžete nastavit od 2 dnů do 30 dnů s výchozím nastavením 7 dnů. Všimněte si, že:

  • Rozšíření okna historie zvyšuje úložiště.
  • Nastavení okna historie má vliv na všechny větve v projektu.

Nastavení okna historie v nastavení projektu Lakebase s posuvníkem pro konfiguraci délky okna obnovení od 2 dnů do 30 dnů.

Projektová oprávnění

Určete, kdo může přistupovat k projektu Lakebase a spravovat ho tím, že udělíte oprávnění k Azure Databricks identitám, skupinám a instančním objektům. Projektová oprávnění určují, jaké akce mohou uživatelé provádět v rámci projektu, jako je vytváření větví, správa výpočetních zdrojů a zobrazení podrobností o připojení.

Typy oprávnění:

  • MŮŽE VYTVOŘIT: Zobrazení a vytvoření zdrojů projektu
  • CAN USE: Zobrazení a používání zdrojů projektu (seznam, zobrazení, připojení a provádění určitých operací větve) bez vytváření nebo odstraňování projektů nebo větví
  • MŮŽE SPRAVOVAT: Úplná kontrola nad konfigurací projektu a zdroji

Výchozí oprávnění:

Při vytváření projektu se automaticky přiřadí následující oprávnění:

  • Vlastník projektu (uživatel, který vytvořil projekt): MŮŽE SPRAVOVAT (plná kontrola)
  • Uživatelé pracovního prostoru: MOHOU VYTVOŘIT (můžou zobrazovat a vytvářet projekty)
  • Správci pracovních prostorů: MŮŽOU SPRAVOVAT (úplné řízení)

Pokud chcete udělit přístup jiným uživatelům, přečtěte si téma Správa oprávnění projektu.

Poznámka:

Oprávnění projektu a přístup k databázi jsou oddělené

Oprávnění projektu řídí akce platformy Lakebase, zatímco přístup k databázi je řízen rolemi Postgres a jejich přidruženými oprávněními. Viz Vytvoření rolí Postgres a Správa oprávnění databáze.

nastavení oprávnění Project

Aktualizace

Aby byly výpočetní prostředky Lakebase a instance Postgres aktuální, lakebase automaticky použije plánované aktualizace, které zahrnují upgrady podverze Postgres, opravy zabezpečení a funkce platformy. Aktualizace se použijí na výpočetní prostředky v rámci projektu a vyžadují krátké restartování výpočetních prostředků, které trvá několik sekund.

Aktualizace se použijí automaticky, ale u aktualizací můžete nastavit upřednostňovaný den a čas. Restartování probíhá v rámci vybraného časového intervalu.

Podrobné informace o aktualizacích najdete v tématu Správa aktualizací.

Aktualizuje nastavení

Odstranění projektu

Když odstraníte projekt, ve výchozím nastavení přejde do stavu dočasného odstranění a zůstane uchován 7 dní, než bude trvale odstraněn. Během tohoto okna můžete projekt obnovit a obnovit všechna jeho data. Viz Obnovení odstraněného projektu. Pokud chcete přeskočit dobu uchovávání a okamžitě projekt odebrat, přečtěte si téma Trvalé odstranění projektu.

Poznámka:

Když je projekt měkce odstraněn, pokusy o připojení k němu nebo o načtení přihlašovacích údajů k databázi vracejí obecné chyby (například že koncový bod nebyl nalezen nebo že bylo připojení odmítnuto) namísto chyby informující o tom, že byl projekt odstraněn. Pokud na tyto chyby narazíte neočekávaně, zkontrolujte pomocí výpisu projektů příkazem show_deleted=true, zda projekt nebyl pouze označen k odstranění. Viz Vyhledání měkce odstraněných projektů.

Před odstraněním

Databricks doporučuje před odstraněním projektu odstranit všechny přidružené katalogy Unity a synchronizované tabulky. V opačném případě při pokusu o zobrazení katalogů nebo spuštění dotazů SQL odkazujících na ně dojde k chybám.

Pokud nejste vlastníkem tabulek nebo katalogů, musíte vlastnictví před odstraněním znovu přiřadit sami sobě.

Poznámka:

Odstranit ho můžou jenom uživatelé s oprávněním CAN MANAGE v projektu Lakebase. Podrobnosti najdete v tématech Seznamy ACL projektů a Správa oprávnění projektu.

Odstranění projektu

Odstranění projektu:

uživatelské rozhraní
  1. Přejděte do nastavení projektu v aplikaci Lakebase.
  2. V části Odstranit projekt klikněte na Odstranit a zadáním názvu projektu potvrďte odstranění.
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()}")

Jedná se o dlouhotrvající operaci. Projekt a všechny jeho prostředky (větve, koncové body, databáze, role, data) se odstraní.

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

Jedná se o dlouhotrvající operaci. Projekt a všechny jeho prostředky (větve, koncové body, databáze, role, data) se odstraní.

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

Tento příkaz se provede okamžitě. Projekt a všechny jeho zdroje budou odstraněny.

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

Jedná se o dlouhotrvající operaci. Odpověď obsahuje název operace, kterou můžete použít ke kontrole stavu odstranění.

Trvalé odstranění projektu

Chcete-li projekt Lakebase trvale smazat okamžitě, aniž byste museli čekat, až uplyne 7denní doba uchování po měkkém odstranění:

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();
CLI
databricks postgres delete-project projects/my-project --purge
kroucení
curl -X DELETE "$WORKSPACE/api/2.0/postgres/projects/my-project?purge=true" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Obnovení odstraněného projektu

Když odstraníte projekt Lakebase, přejde do stavu měkkého odstranění a zůstane uchován 7 dnů, než bude trvale odstraněn. Během tohoto okna můžete projekt obnovit a obnovit všechna jeho data.

Co je obnoveno

Obnovením dočasně odstraněného projektu se obnoví následující:

  • Všechny větve a jejich data
  • Všechny databáze a role v Postgresu
  • Všechny výpočetní koncové body a jejich konfigurace
  • Nastavení projektu, včetně výchozího nastavení výpočetních prostředků, nastavení okna obnovení a předvoleb pro aktualizace
  • Oprávnění projektu

Poznámka:

Některé prostředky můžou po obnovení vyžadovat rekonfiguraci. Pokud po obnovení projektu narazíte na problémy, obraťte se na podporu Databricks .

Vyhledání dočasně odstraněných projektů

Pokud chcete zobrazit seznam všech projektů včetně obnovitelně odstraněných projektů, použijte show_deleted parametr. To je užitečné pro vyhledání názvu zdroje projektu, který chcete obnovit.

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}")
CLI
databricks postgres list-projects --show-deleted
kroucení
curl -X GET "$WORKSPACE/api/2.0/postgres/projects?show_deleted=true" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Obnovení projektu

Chcete-li obnovit měkce odstraněný projekt Lakebase:

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();
CLI
databricks postgres undelete-project projects/my-project
kroucení
curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/undelete" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq
  • Last updated on