Hantera beräkningar

En beräkningstjänst är en virtualiserad tjänst som kör Postgres för dina Lakebase-projekt. Varje gren har en primär (läs-skriv) beräkningsenhet. En beräkning krävs för att ansluta till en gren och komma åt dess data. En översikt över hur beräkningar och slutpunkter relaterar finns i Beräkning och slutpunkter.

Förstå beräkningar

Beräkningsöversikt

Beräkningsresurser ger den bearbetningskraft och det minne som krävs för att köra frågor, hantera anslutningar och hantera databasåtgärder. Varje projekt har en primär läs- och skrivberäkning för sin standardgren.

Om du vill ansluta till en databas i en gren måste du använda en beräkning som är associerad med den grenen. Större beräkningar förbrukar fler beräkningstimmar under samma aktiva tid än mindre beräkningar.

Beräkningsidentifierare

Varje beräkning har tre identifierare som är tillgängliga från menyn Hämta ID på fliken Beräkning:

Värdnamnet i din reťazec pripojenia använder UID, inte beräkningsnamnet.

Beräkningsstorlek

Tillgängliga beräkningsstorlekar

Lakebase Postgres stöder följande beräkningsstorlekar:

• Beräkningsresurser med automatisk skalning: 0,5 CU till 64 CU (0,5, därefter i heltalssteg: 1, 2, 3... 64)
• Större beräkningar med fast storlek: 65 CU till 112 CU

Vad finns i en beräkningsenhet?

Varje beräkningsenhet (CU) allokerar cirka 2 GB RAM-minne till databasinstansen, tillsammans med alla associerade CPU- och lokala SSD-resurser. Om du skalar upp ökar resurserna linjärt. Postgres distribuerar det allokerade minnet mellan flera komponenter:

• Databascacher
• Arbetsminne
• Andra processer med krav på fast minne

Prestanda varierar beroende på datastorlek och frågekomplexitet. Testa och optimera frågor innan du skalar. Lagringen skalas automatiskt.

Beräkningsspecifikationer

Anslutningsgränser för beräkning av automatisk skalning: När automatisk skalning är aktiverat bestäms det maximala antalet anslutningar av det mindre av din maximala CU och 8× din lägsta CU. Om du till exempel konfigurerar automatisk skalning mellan 2–8 CU är anslutningsgränsen 1 795 (gränsen för 8 CU).

Gränser för läsreplikanslutningar: Anslutningsgränser för läsreplikor synkroniseras med dina primära läs- och skrivinställningar för beräkning. Mer information finns i Hantera läsrepliker .

Vägledning för storleksval

När du väljer en beräkningsstorlek bör du tänka på följande faktorer:

Optimal storleksstrategi

Välj en beräkningsstorlek baserat på dina datakrav:

• Fullständig datauppsättning i minnet: Välj en beräkningsstorlek som kan lagra hela datamängden i minnet för bästa prestanda
• Arbetsuppsättning i minnet: För stora datamängder, se till att dina ofta använda data passar i minnet
• Anslutningsgränser: Välj en storlek som stöder dina förväntade maximala samtidiga anslutningar

Autoskalning

Lakebase stöder beräkningskonfigurationer med både fast storlek och automatisk skalning. Autoskalning justerar dynamiskt beräkningsresurser baserat på arbetsbelastningens efterfrågan, vilket optimerar både prestanda och kostnad.

Automatisk skalningsgräns: Autoskalning stöds för beräkningar upp till 64 CU (128 GB). För arbetsbelastningar som kräver mer än 64 CU finns större fasta beräkningsinstanser på 80, 96 eller 112 CU.

Konfigurera automatisk skalning

Om du vill aktivera eller justera autoskalning för en beräkning redigerar du beräkningen och använder skjutreglaget för att ange minsta och högsta beräkningsstorlekar.

En översikt över hur autoskalning fungerar finns i Autoskalning.

Överväganden för automatisk skalning

För optimal prestanda vid autoskalning:

• Ange den minsta beräkningsstorleken som är tillräckligt stor för att cachelagma din arbetsuppsättning i minnet
• Tänk på att dåliga prestanda kan uppstå tills beräkningen skalas upp och cachelagrar dina data
• Dina anslutningsgränser baseras på den mindre av din maximala CU och 8× din lägsta CU

Begränsningar för autoskalningsintervall: Skillnaden mellan dina högsta och minsta beräkningsstorlekar får inte överstiga 16 CU (d.s.a max - min ≤ 16 CU. ). Du kan till exempel konfigurera automatisk skalning från 8 till 24 CU, eller från 48 till 64 CU, men inte från 0,5 till 32 CU (vilket skulle vara ett 31,5 CU-intervall). Skjutreglaget i Lakebase-appen tillämpar den här begränsningen automatiskt. För arbetsbelastningar som kräver mer än 64 CU använder du större beräkningsinstanser av fast storlek upp till 112 CU.

Skala till noll

Lakebase-funktionen scale-to-zero överför automatiskt en beräkning till ett inaktivt tillstånd efter en period av inaktivitet, vilket minskar kostnaderna för databaser som inte är kontinuerligt aktiva.

En översikt över hur skalning till noll fungerar finns i Skala till noll. Information om hur du konfigurerar skalning till noll för en beräkning finns i Konfigurera skalning till noll.

Skapa och hantera beräkningar

Visa beräkningar

Visa i användargränssnittet

Om du vill visa beräkningen för en gren går du till projektets grenar-sida i Lakebase-appen och väljer en gren för att visa fliken Beräkning .

Fliken Beräkning visar information om alla beräkningar som är associerade med grenen. Informationen som visas på fliken Computes beskrivs i följande tabell.

För varje beräkning kan du:

• Klicka på Anslut för att öppna en anslutningsdialogruta med anslutningsinformation för den gren som är associerad med beräkningen. Dialogrutan innehåller en växlingsknapp för anslutningspooling för inbyggda Postgres-lösenordsroller. Se Ansluta till databasen och Använd anslutningspooler.
• Klicka på Redigera för att ändra beräkningsstorleken (fast eller automatiskt skalningsintervall) och konfigurera inställningar för skalning till noll. Se Redigera en beräkning.
• Klicka på menyikonen för att få åtkomst till ytterligare alternativ:
  • Övervaka aktivitet: Visa beräkningsaktivitet och prestandamått. Se Övervaka din databas.
  • Starta om beräkning: Starta om beräkningen för att lösa anslutningsproblem eller tillämpa konfigurationsändringar. Se Starta om en beräkning.

Om du vill lägga till en läsreplik-beräkning till grenen klickar du på Lägg till läsreplik. Skrivskyddade repliker är skrivskyddade beräkningar som möjliggör horisontell skalning genom att låta dig avlasta läsarbetsbelastningen från din primära beräkning. Se Läs repliker och Hantera läsrepliker.

Hämta en beräkning programmatiskt

Så här hämtar du information om en specifik beräkning med postgres-API:et:

Python SDK

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

I SDK:et får du åtkomst till värden via endpoint.status.hosts.host (inte endpoint.status.host).

Java SDK

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

Kommandoradsgränssnitt (CLI)

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

lockig

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

Lista beräkningar genom programkod

Så här listar du alla beräknings- och läsrepliker för en gren med postgres-API:et:

Python SDK

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

I SDK:et får du åtkomst till värden via endpoint.status.hosts.host (inte endpoint.status.host).

Java SDK

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

Kommandoradsgränssnitt (CLI)

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

lockig

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

Redigera en beräkning

Du kan redigera en beräkning för att ändra dess storlek, konfiguration av automatisk skalning eller skalning till noll-inställningar. Beräkningsnamn är skrivskyddade och kan inte byta namn.

Så här redigerar du en beräkning:

Användargränssnitt (UI)

1. Gå till din branchs Computes-flik i Lakebase-appen.
2. Klicka på Redigera för beräkningen, justera inställningarna och klicka på Spara.

Python SDK

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

Om du vill uppdatera flera fält tar du med dem i både specifikationen och uppdateringsmasken:

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

Java SDK

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

Om du vill uppdatera flera fält tar du med dem i både specifikationen och uppdateringsmasken:

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

Kommandoradsgränssnitt (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
    }
  }'

lockig

# 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

Konfigurera skalning till noll

Om du vill konfigurera skalning till noll tar du med spec.suspension i uppdateringsmasken. Ange suspend_timeout_duration (60s–604800s) för att definiera tidsgränsen för inaktivitet eller no_suspension: true för att inaktivera den. Ange inte båda. Inställningen no_suspension: false är ogiltig och returnerar ett fel. Som standard har grenen production skalning till noll aktiverat med en tidsgräns på 24 timmar.

Användargränssnitt (UI)

1. Gå till din branchs Computes-flik i Lakebase-appen.
2. Klicka på Redigera för beräkning och aktivera eller inaktivera inställningen skala till noll. När du är aktiverad konfigurerar du tidsgränsen för inaktivitet mellan 60 sekunder och 7 dagar.
3. Klicka på Spara.

Python SDK

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

Java SDK

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

Kommandoradsgränssnitt (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"
    }
  }'

lockig

# 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

Inaktivera eller aktivera en beräkning

Om du inaktiverar en beräkning pausas den och alla nya anslutningar blockeras. Till skillnad från skala till noll kan en inaktiverad beräkning inte väckas av ett anslutningsförsök eller från Lakebase-appen. Om du vill återaktivera den använder du API:et.

Python SDK

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

Om du vill kontrollera om en beräkning för närvarande är inaktiverad läser du värdet från slutpunktens status. Du ställer in värdet på spec.disabled, men läser tillbaka det från 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

Kommandoradsgränssnitt (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
    }
  }'

Om du vill kontrollera om en compute-resurs för närvarande är inaktiverad, läser du status.disabled från ändpunkten:

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

lockig

# 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

Om du vill kontrollera om en compute-resurs för närvarande är inaktiverad, läser du status.disabled från ändpunkten:

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

Starta om en beräkning

Starta om en beräkning för att tillämpa uppdateringar, lösa prestandaproblem eller hämta konfigurationsändringar.

Så här startar du om en beräkning:

1. Gå till din branchs Computes-flik i Lakebase-appen.
2. Klicka på Meny för beräkning, välj Starta om och bekräfta åtgärden.

Ytterligare resurser

• Översikt för mätvärden
• Automatisk skalning
• Skala till noll
• Läs repliker