Administración de recursos informáticos

Una instancia de cómputo es un servicio virtualizado que ejecuta PostgreSQL para los proyectos de Lakebase. Cada rama tiene un cómputo principal (de lectura y escritura). Se requiere un equipo para conectarse a una sucursal y acceder a sus datos. Para obtener información general sobre cómo se relacionan los procesos y los puntos de conexión, consulte Proceso y puntos de conexión.

Comprender la informática

Información general sobre computación

Los recursos de proceso proporcionan la capacidad de procesamiento y la memoria necesarias para ejecutar consultas, administrar conexiones y controlar las operaciones de base de datos. Cada proyecto tiene un recurso de computación de lectura-escritura principal para su rama predeterminada.

Para conectarse a una base de datos en una filial, debe usar una computadora asociada a esa filial. Los procesos más grandes consumen más horas de proceso durante el mismo período de tiempo activo que los procesos más pequeños.

Identificadores de proceso

Cada proceso tiene tres identificadores, accesibles desde el menú Obtener identificador en la pestaña Procesos:

El nombre de host de la cadena de conexión usa el UID, no el nombre de equipo.

Ajuste de tamaño de proceso

Tamaños de cálculo disponibles

Lakebase Postgres admite los siguientes tamaños de proceso:

• Proceso con escalado automático: de 0,5 CU a 64 CU (0,5 y luego incrementos enteros: 1, 2, 3... 64)
• Instancias de computación de tamaño fijo más grandes: de 65 CU a 112 CU

¿Qué hay en una unidad de proceso?

Cada unidad de proceso (CU) asigna aproximadamente 2 GB de RAM a la instancia de base de datos, junto con todos los recursos de CPU y SSD locales asociados. El escalado aumenta estos recursos de forma lineal. Postgres distribuye la memoria asignada entre varios componentes:

• Cachés de bases de datos
• Memoria de trabajo
• Otros procesos con requisitos fijos de memoria

El rendimiento varía en función del tamaño de los datos y la complejidad de las consultas. Antes de escalar, probar y optimizar las consultas. El almacenamiento se escala automáticamente.

Especificaciones de cómputo

Límites de conexión para los recursos de procesamiento con escalado automático: Cuando se habilita el escalado automático, el número máximo de conexiones se determina por el valor menor entre su CU máximo y 8× su CU mínima. Por ejemplo, si configura el escalado automático entre 2 y 8 CU, el límite de conexión es 1795 (el límite de 8 CU).

Límites de conexión de réplicas de lectura: los límites de conexión de proceso de réplicas de lectura se sincronizan con las configuraciones principales de proceso de lectura y escritura. Consulte Administración de réplicas de lectura para obtener más información.

Guía de ajuste de tamaño

Al seleccionar un tamaño de computación, considere estos factores:

Estrategia de ajuste de tamaño óptimo

Seleccione un tamaño de proceso en función de los requisitos de datos:

• Conjunto de datos completo en memoria: elija un tamaño de proceso que pueda contener todo el conjunto de datos en memoria para obtener el mejor rendimiento.
• Conjunto de trabajo en memoria: para grandes conjuntos de datos, asegúrese de que sus datos más utilizados quepan en la memoria.
• Límites de conexión: seleccione un tamaño que admita las conexiones simultáneas máximas previstas.

Escalado automático

Lakebase admite configuraciones de proceso de tamaño fijo y escalado automático. El escalado automático ajusta dinámicamente los recursos de proceso en función de la demanda de la carga de trabajo, optimizando tanto el rendimiento como el costo.

Límite de escalado automático: El escalado automático se admite para los procesos de hasta 64 CU (128 GB). Para cargas de trabajo que requieran más de 64 CU, están disponibles cómputos de tamaño fijo de 80, 96 o 112 CU.

Configuración del escalado automático

Para habilitar o ajustar el escalado automático de un proceso, edite el proceso y use el control deslizante para establecer tamaños de proceso mínimo y máximo.

Para obtener información general sobre cómo funciona el escalado automático, consulte Escalado automático.

Consideraciones de escalado automático

Para obtener un rendimiento óptimo del escalado automático:

• Establezca el tamaño mínimo de proceso lo suficientemente grande como para almacenar en caché el conjunto de trabajo en memoria
• Tenga en cuenta que puede producirse un rendimiento deficiente hasta que el proceso se escala verticalmente y almacena en caché los datos.
• Sus límites de conexión se basan en el valor menor entre su CU máxima y 8× su CU mínima.

Restricciones de intervalo de escalado automático: la diferencia entre los tamaños de proceso máximo y mínimo no puede superar los 16 CU (es decir, max - min ≤ 16 CU). Por ejemplo, puede configurar el escalado automático de 8 a 24 CU, o de 48 a 64 CU, pero no de 0,5 a 32 CU (que sería un intervalo de 31,5 CU). El control deslizante de la aplicación Lakebase aplica esta restricción automáticamente. Para las cargas de trabajo que requieren más de 64 CU, utilice instancias de proceso de tamaño fijo más grandes, de hasta 112 CU.

Escalar a cero

La característica de escala a cero de Lakebase realiza automáticamente la transición de un proceso a un estado inactivo después de un período de inactividad, lo que reduce los costos de las bases de datos que no están activas continuamente.

Para obtener información general sobre cómo funciona la escala a cero, consulte Escalado a cero. Para configurar la escala en cero para un proceso, consulte Configuración de la escala en cero.

Crear y gestionar recursos de cómputo

Ver procesos

Ver en la interfaz de usuario

Para ver los procesos de una rama, vaya a la página Ramas del proyecto en la aplicación Lakebase y seleccione una rama para ver su pestaña Procesos .

La pestaña Computes (Procesos) muestra información sobre todos los procesos asociados a la rama. La información que se muestra en la pestaña Computes (Procesos) se describe en la tabla siguiente.

Para cada proceso, puede:

• Haga clic en Conectar para abrir un cuadro de diálogo de conexión con los detalles de conexión de la rama asociada al proceso. El cuadro de diálogo incluye un botón de alternancia Agrupación de conexiones para roles nativos de contraseña de Postgres. Consulte Conexión a la base de datos y Uso de la agrupación de conexiones.
• Haga clic en Editar para modificar el tamaño de proceso (intervalo fijo o de escalado automático) y configurar la configuración de escalado a cero. Consulte Editar una instancia de cómputo.
• Haga clic en el icono de menú para acceder a opciones adicionales:
  • Supervisión de la actividad: Visualice la actividad de cómputo y las métricas de rendimiento. Consulte Supervisión de la base de datos.
  • Reiniciar proceso: reinicie el proceso para resolver problemas de conexión o aplicar cambios de configuración. Consulte Reiniciar un proceso.

Para agregar un proceso de réplica de lectura a la rama, haga clic en Agregar réplica de lectura. Las réplicas de lectura son procesos de solo lectura que permiten el escalado horizontal, ya que le permiten descargar la carga de trabajo de lectura del proceso principal. Consulte Réplicas de lectura y Administrar réplicas de lectura.

Obtener un cálculo de forma programática

Para obtener detalles sobre un proceso específico mediante postgres API:

SDK de Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Get endpoint details
endpoint = w.postgres.get_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute"
)

print(f"Endpoint: {endpoint.name}")
print(f"Type: {endpoint.status.endpoint_type}")
print(f"State: {endpoint.status.current_state}")
print(f"Host: {endpoint.status.hosts.host}")
print(f"Min CU: {endpoint.status.autoscaling_limit_min_cu}")
print(f"Max CU: {endpoint.status.autoscaling_limit_max_cu}")

En el SDK, acceda al host a través de endpoint.status.hosts.host (no endpoint.status.host).

SDK de Java

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

WorkspaceClient w = new WorkspaceClient();

// Get endpoint details
Endpoint endpoint = w.postgres().getEndpoint(
    "projects/my-project/branches/production/endpoints/my-compute"
);

System.out.println("Endpoint: " + endpoint.getName());
System.out.println("Type: " + endpoint.getStatus().getEndpointType());
System.out.println("State: " + endpoint.getStatus().getCurrentState());
System.out.println("Host: " + endpoint.getStatus().getHosts().getHost());
System.out.println("Min CU: " + endpoint.getStatus().getAutoscalingLimitMinCu());
System.out.println("Max CU: " + endpoint.getStatus().getAutoscalingLimitMaxCu());

Interfaz de línea de comandos (CLI)

# Get endpoint details
databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq

curl

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

Listar cálculos programáticamente

Para enumerar todos los procesos y las réplicas de lectura de una rama mediante la API de Postgres:

SDK de Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# List all endpoints for a branch
endpoints = list(w.postgres.list_endpoints(
    parent="projects/my-project/branches/production"
))

for endpoint in endpoints:
    print(f"Endpoint: {endpoint.name}")
    print(f"  Type: {endpoint.status.endpoint_type}")
    print(f"  State: {endpoint.status.current_state}")
    print(f"  Host: {endpoint.status.hosts.host}")
    print(f"  CU Range: {endpoint.status.autoscaling_limit_min_cu}-{endpoint.status.autoscaling_limit_max_cu}")
    print()

En el SDK, acceda al host a través de endpoint.status.hosts.host (no endpoint.status.host).

SDK de Java

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

WorkspaceClient w = new WorkspaceClient();

// List all endpoints for a branch
for (Endpoint endpoint : w.postgres().listEndpoints("projects/my-project/branches/production")) {
    System.out.println("Endpoint: " + endpoint.getName());
    System.out.println("  Type: " + endpoint.getStatus().getEndpointType());
    System.out.println("  State: " + endpoint.getStatus().getCurrentState());
    System.out.println("  Host: " + endpoint.getStatus().getHosts().getHost());
    System.out.println("  CU Range: " + endpoint.getStatus().getAutoscalingLimitMinCu() +
        "-" + endpoint.getStatus().getAutoscalingLimitMaxCu());
    System.out.println();
}

Interfaz de línea de comandos (CLI)

# List endpoints for a branch
databricks postgres list-endpoints projects/my-project/branches/production --output json | jq

curl

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

Editar proceso

Puede editar un recurso de computación para cambiar su tamaño, la configuración de escalado automático o la configuración para escalar a cero. Los nombres de proceso son de solo lectura y no se pueden cambiar de nombre.

Para editar un recurso computacional:

Interfaz de usuario

1. Vaya a la pestaña Computes de tu rama en la aplicación Lakebase.
2. Haga clic en Editar para el proceso, ajuste la configuración y haga clic en Guardar.

SDK de Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType, FieldMask

w = WorkspaceClient()

# Update a single field (max CU)
endpoint_spec = EndpointSpec(endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE, autoscaling_limit_max_cu=6.0)
endpoint = Endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    spec=endpoint_spec
)

result = w.postgres.update_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    endpoint=endpoint,
    update_mask=FieldMask(field_mask=["spec.autoscaling_limit_max_cu"])
).wait()

print(f"Updated max CU: {result.status.autoscaling_limit_max_cu}")

Para actualizar varios campos, inclúyelos tanto en la especificación como en la máscara de actualización:

# Update multiple fields (min and max CU)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    autoscaling_limit_min_cu=1.0,
    autoscaling_limit_max_cu=8.0
)
endpoint = Endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    spec=endpoint_spec
)

result = w.postgres.update_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    endpoint=endpoint,
    update_mask=FieldMask(field_mask=[
        "spec.autoscaling_limit_min_cu",
        "spec.autoscaling_limit_max_cu"
    ])
).wait()

print(f"Updated min CU: {result.status.autoscaling_limit_min_cu}")
print(f"Updated max CU: {result.status.autoscaling_limit_max_cu}")

SDK de Java

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

WorkspaceClient w = new WorkspaceClient();

// Update a single field (max CU)
EndpointSpec endpointSpec = new EndpointSpec()
    .setAutoscalingLimitMaxCu(6.0);

FieldMask updateMask = FieldMask.newBuilder()
    .addPaths("spec.autoscaling_limit_max_cu")
    .build();

w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName("projects/my-project/branches/production/endpoints/my-compute")
        .setEndpoint(new Endpoint().setSpec(endpointSpec))
        .setUpdateMask(updateMask)
);

System.out.println("Update initiated");

Para actualizar varios campos, inclúyelos tanto en la especificación como en la máscara de actualización:

// Update multiple fields (min and max CU)
EndpointSpec endpointSpec = new EndpointSpec()
    .setAutoscalingLimitMinCu(1.0)
    .setAutoscalingLimitMaxCu(8.0);

FieldMask updateMask = FieldMask.newBuilder()
    .addPaths("spec.autoscaling_limit_min_cu")
    .addPaths("spec.autoscaling_limit_max_cu")
    .build();

w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName("projects/my-project/branches/production/endpoints/my-compute")
        .setEndpoint(new Endpoint().setSpec(endpointSpec))
        .setUpdateMask(updateMask)
);

System.out.println("Update initiated");

Interfaz de línea de comandos (CLI)

# Update a single field (max CU)
databricks postgres update-endpoint projects/my-project/branches/production/endpoints/my-compute spec.autoscaling_limit_max_cu \
  --json '{
    "spec": {
      "autoscaling_limit_max_cu": 6.0
    }
  }'

# Update multiple fields (min and max CU)
databricks postgres update-endpoint projects/my-project/branches/production/endpoints/my-compute "spec.autoscaling_limit_min_cu,spec.autoscaling_limit_max_cu" \
  --json '{
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }'

curl

# Update a single field (max CU)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.autoscaling_limit_max_cu" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "autoscaling_limit_max_cu": 6.0
    }
  }' | jq

# Update multiple fields (min and max CU)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.autoscaling_limit_min_cu,spec.autoscaling_limit_max_cu" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }' | jq

Configuración de la escala en cero

Para configurar la escala a cero, incluya spec.suspension en la máscara de actualización. Establezca suspend_timeout_duration (60s–604800s) para definir el tiempo de espera de inactividad o no_suspension: true para deshabilitarlo. No configure ninguna. La configuración no_suspension: false no es válida y devuelve un error. De forma predeterminada, la production rama tiene la escala a cero habilitada con un tiempo de espera de 24 horas.

Interfaz de usuario

1. Vaya a la pestaña Computes de tu rama en la aplicación Lakebase.
2. Haga clic en Editar para el proceso y, a continuación, habilite o deshabilite la configuración de escalado a cero. Cuando se habilita, configure el tiempo de espera de inactividad entre 60 segundos y 7 días.
3. Haz clic en Guardar.

SDK de Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType, FieldMask
from google.protobuf.duration_pb2 import Duration

w = WorkspaceClient()
endpoint_name = "projects/my-project/branches/production/endpoints/my-compute"

# Disable scale to zero (compute stays active indefinitely)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    no_suspension=True
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.suspension"])
).wait()

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    suspend_timeout_duration=Duration(seconds=300)
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.suspension"])
).wait()

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();
String endpointName = "projects/my-project/branches/production/endpoints/my-compute";

FieldMask updateMask = FieldMask.newBuilder()
    .addPaths("spec.suspension")
    .build();

// Disable scale to zero (compute stays active indefinitely)
EndpointSpec noSuspensionSpec = new EndpointSpec()
    .setNoSuspension(true);
w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName(endpointName)
        .setEndpoint(new Endpoint().setSpec(noSuspensionSpec))
        .setUpdateMask(updateMask)
);

// Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
EndpointSpec timeoutSpec = new EndpointSpec()
    .setSuspendTimeoutDuration(
        Duration.newBuilder().setSeconds(300).build()
    );
w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName(endpointName)
        .setEndpoint(new Endpoint().setSpec(timeoutSpec))
        .setUpdateMask(updateMask)
);

Interfaz de línea de comandos (CLI)

# Disable scale to zero (compute stays active indefinitely)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.suspension \
  --json '{
    "spec": {
      "no_suspension": true
    }
  }'

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.suspension \
  --json '{
    "spec": {
      "suspend_timeout_duration": "300s"
    }
  }'

curl

# Disable scale to zero (compute stays active indefinitely)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.suspension" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "no_suspension": true
    }
  }' | jq

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.suspension" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "suspend_timeout_duration": "300s"
    }
  }' | jq

Deshabilitar o habilitar un cómputo

Deshabilitar una instancia de cómputo la suspende y bloquea todas las conexiones nuevas. A diferencia del escalado a cero, un recurso de proceso deshabilitado no puede activarse mediante un intento de conexión ni desde la aplicación de Lakebase. Para volver a habilitarlo, use la API.

SDK de Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType, FieldMask

w = WorkspaceClient()
endpoint_name = "projects/my-project/branches/production/endpoints/my-compute"

# Disable a compute (blocks all connections)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    disabled=True
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.disabled"])
).wait()

# Re-enable a compute
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    disabled=False
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.disabled"])
).wait()

Para comprobar si un recurso de cómputo está deshabilitado actualmente, lea el valor del estado del endpoint. Estableces el valor en spec.disabled, pero lo vuelves a leer desde status.disabled:

endpoint = w.postgres.get_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute"
)
print(endpoint.status.disabled)  # True = disabled, False or None = enabled

Interfaz de línea de comandos (CLI)

# Disable a compute (blocks all connections)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.disabled \
  --json '{
    "spec": {
      "disabled": true
    }
  }'

# Re-enable a compute
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.disabled \
  --json '{
    "spec": {
      "disabled": false
    }
  }'

Para comprobar si un recurso de cómputo está desactivado actualmente, lea status.disabled en el endpoint:

databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq '.status.disabled'

curl

# Disable a compute (blocks all connections)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.disabled" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "disabled": true
    }
  }' | jq

# Re-enable a compute
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.disabled" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "disabled": false
    }
  }' | jq

Para comprobar si un recurso de cómputo está desactivado actualmente, lea status.disabled en el endpoint:

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq '.status.disabled'

Reiniciar proceso

Reinicie un proceso para aplicar actualizaciones, resolver problemas de rendimiento o recoger los cambios de configuración.

Para reiniciar un equipo:

1. Vaya a la pestaña Computes de tu rama en la aplicación Lakebase.
2. Haga clic en el para el menú de cómputo, seleccione Reiniciar y confirme la operación.

Recursos adicionales

• Panel de métricas
• Escalabilidad automática
• Reducido a cero
• Réplicas de lectura