Een maximaal beschikbare PostgreSQL-database implementeren in Azure Kubernetes Service (AKS)

In dit artikel implementeert u een maximaal beschikbare PostgreSQL-database op AKS.

• Als u nog steeds de vereiste infrastructuur voor deze implementatie moet maken, volgt u de stappen in Infrastructuur maken voor het implementeren van een maximaal beschikbare PostgreSQL-database op AKS om te worden ingesteld en keert u terug naar dit artikel.

Geheim maken voor bootstrap-app-gebruiker

1. Genereer een geheim om de PostgreSQL-implementatie te valideren door interactieve aanmelding voor een bootstrap-app-gebruiker met behulp van de kubectl create secret opdracht.

PG_DATABASE_APPUSER_SECRET=$(echo -n | openssl rand -base64 16)

kubectl create secret generic db-user-pass \
    --from-literal=username=app \
     --from-literal=password="${PG_DATABASE_APPUSER_SECRET}" \
     --namespace $PG_NAMESPACE \
     --context $AKS_PRIMARY_CLUSTER_NAME

1. Controleer of het geheim is gemaakt met behulp van de kubectl get opdracht.

   kubectl get secret db-user-pass --namespace $PG_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
   

Omgevingsvariabelen instellen voor het PostgreSQL-cluster

• Implementeer een ConfigMap om de CNPG-operator te configureren met behulp van de volgende kubectl apply opdracht. Deze waarden vervangen de verouderde ENABLE_AZURE_PVC_UPDATES schakelaar, die niet meer vereist is, en helpen bij het gefaseerd uitvoeren van upgrades en het versnellen van het verbindingsherstel van replica's. Voordat u deze configuratie in productie gaat implementeren, moet u controleren of alle bestaande DRAIN_TAINTS instellingen die u vertrouwt compatibel blijven met uw Azure-omgeving.

  cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME -n $PG_NAMESPACE -f -
  apiVersion: v1
  kind: ConfigMap
  metadata:
      name: cnpg-controller-manager-config
  data:
      CLUSTERS_ROLLOUT_DELAY: '120'
      STANDBY_TCP_USER_TIMEOUT: '10'
  EOF
  

De Prometheus PodMonitors installeren

Prometheus scrapet CNPG met behulp van de opnameregels die zijn opgeslagen in de CNPG GitHub-voorbeelden opslagplaats. Omdat de door de operator beheerde PodMonitor wordt afgeschaft, maakt en beheert u de PodMonitor-resource zelf, zodat u deze kunt aanpassen aan uw bewakingsstack.

1. Voeg de Prometheus Community Helm-opslagplaats toe met de helm repo add opdracht.

   helm repo add prometheus-community \
       https://prometheus-community.github.io/helm-charts
   

2. Werk de Prometheus Community Helm-opslagplaats bij en installeer deze op het primaire cluster met behulp van de helm upgrade opdracht met de --install vlag.

   helm upgrade --install \
       --namespace $PG_NAMESPACE \
       -f https://raw.githubusercontent.com/cloudnative-pg/cloudnative-pg/main/docs/src/samples/monitoring/kube-stack-config.yaml \
       prometheus-community \
       prometheus-community/kube-prometheus-stack \
       --kube-context=$AKS_PRIMARY_CLUSTER_NAME
   

3. Maak een PodMonitor voor het cluster. Het CNPG-team beëindigt de door de operator beheerde PodMonitor, zodat u het nu rechtstreeks beheert:

   cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE -f -
   apiVersion: monitoring.coreos.com/v1
   kind: PodMonitor
   metadata:
     name: $PG_PRIMARY_CLUSTER_NAME
     namespace: ${PG_NAMESPACE}
     labels:
       cnpg.io/cluster: ${PG_PRIMARY_CLUSTER_NAME}
   spec:
     selector:
       matchLabels:
         cnpg.io/cluster: ${PG_PRIMARY_CLUSTER_NAME}
     podMetricsEndpoints:
       - port: metrics
   EOF
   

Een federatieve inloggegevens maken

In deze sectie maakt u een federatieve identiteitsreferentie voor PostgreSQL-back-up, zodat CNPG AKS-workloadidentiteit kan gebruiken om te verifiëren bij de bestemming van het opslagaccount voor back-ups. De CNPG-operator maakt een Kubernetes-serviceaccount met dezelfde naam als het cluster dat wordt gebruikt in het CNPG-clusterimplementatiemanifest.

1. Haal de URL van de OIDC-verlener van het cluster op met behulp van de az aks show opdracht.

   export AKS_PRIMARY_CLUSTER_OIDC_ISSUER="$(az aks show \
       --name $AKS_PRIMARY_CLUSTER_NAME \
       --resource-group $RESOURCE_GROUP_NAME \
       --query "oidcIssuerProfile.issuerUrl" \
       --output tsv)"
   

2. Maak een federatieve identiteitsreferentie met behulp van de az identity federated-credential create opdracht.

   az identity federated-credential create \
       --name $AKS_PRIMARY_CLUSTER_FED_CREDENTIAL_NAME \
       --identity-name $AKS_UAMI_CLUSTER_IDENTITY_NAME \
       --resource-group $RESOURCE_GROUP_NAME \
       --issuer "${AKS_PRIMARY_CLUSTER_OIDC_ISSUER}" \
       --subject system:serviceaccount:"${PG_NAMESPACE}":"${PG_PRIMARY_CLUSTER_NAME}" \
       --audience api://AzureADTokenExchange
   

Een postgreSQL-cluster met hoge beschikbaarheid implementeren

In deze sectie implementeert u een PostgreSQL-cluster met hoge beschikbaarheid met behulp van de CNPG Cluster Custom Resource Definition (CRD).

CRD-parameters voor cluster

De volgende tabel bevat een overzicht van de belangrijkste eigenschappen die zijn ingesteld in het YAML-implementatiemanifest voor de CLUSTER CRD:

Als u PostgreSQL-workloads verder wilt isoleren, kunt u een taint (bijvoorbeeld node-role.kubernetes.io/postgres=:NoSchedule) toevoegen aan uw gegevensvlakknooppunten en het voorbeeld nodeSelector/tolerations vervangen door de waarden die door CloudNativePG worden aanbevolen. Als u deze aanpak volgt, labelt u de knooppunten dienovereenkomstig en bevestigt u dat het AKS-beleid voor automatische schaalaanpassing overeenkomt met uw topologie.

PostgreSQL-prestatieparameters

De prestaties van PostgreSQL zijn sterk afhankelijk van de onderliggende resources en workload van uw cluster. De volgende tabel bevat basislijnrichtlijnen voor een cluster met drie knooppunten dat wordt uitgevoerd op Standard D4s v3-knooppunten (16-GiB-geheugen). Behandel deze waarden als uitgangspunt en pas deze aan wanneer u uw workloadprofiel begrijpt:

PostgreSQL implementeren

2. Controleer of het primaire PostgreSQL-cluster is gemaakt met behulp van de kubectl get opdracht. Het CNPG-cluster CRD heeft drie exemplaren opgegeven, die kunnen worden gevalideerd door actieve pods weer te geven zodra elk exemplaar wordt opgehaald en toegevoegd voor replicatie. Wees geduldig omdat het enige tijd kan duren voordat alle drie de exemplaren online zijn en deelnemen aan het cluster.

   kubectl get pods --context $AKS_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE -l cnpg.io/cluster=$PG_PRIMARY_CLUSTER_NAME
   

   Voorbeelduitvoer

   NAME                         READY   STATUS    RESTARTS   AGE
   pg-primary-cnpg-r8c7unrw-1   1/1     Running   0          4m25s
   pg-primary-cnpg-r8c7unrw-2   1/1     Running   0          3m33s
   pg-primary-cnpg-r8c7unrw-3   1/1     Running   0          2m49s
   

kubectl cnpg destroy [cnpg-cluster-name] [instance-number]  

Valideren dat Prometheus PodMonitor wordt uitgevoerd

De handmatig gemaakte PodMonitor koppelt de kube-prometheus-stack-scrape-configuratie aan de CNPG-pods die u eerder hebt geïmplementeerd.

Controleer of PodMonitor wordt uitgevoerd met behulp van de kubectl get opdracht.

kubectl --namespace $PG_NAMESPACE \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    get podmonitors.monitoring.coreos.com \
    $PG_PRIMARY_CLUSTER_NAME \
    --output yaml

Voorbeelduitvoer

kind: PodMonitor
metadata:
  labels:
    cnpg.io/cluster: pg-primary-cnpg-r8c7unrw
  name: pg-primary-cnpg-r8c7unrw
  namespace: cnpg-database
spec:
  podMetricsEndpoints:
  - port: metrics
  selector:
    matchLabels:
      cnpg.io/cluster: pg-primary-cnpg-r8c7unrw

Als u Azure Monitor voor Beheerde Prometheus gebruikt, moet u een extra podmonitor toevoegen met de aangepaste groepsnaam. Beheerde Prometheus haalt de aangepaste resourcedefinities (CRD's) niet op van de Prometheus-community. Afgezien van de groepsnaam zijn de CRD's hetzelfde. Met dit ontwerp kunnen podmonitors voor Beheerde Prometheus worden uitgevoerd naast podmonitors die gebruikmaken van de CRD van de community. Als u beheerde Prometheus niet gebruikt, kunt u deze sectie overslaan. Maak een nieuwe podmonitor:

cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE -f -
apiVersion: azmonitoring.coreos.com/v1
kind: PodMonitor
metadata:
  name: cnpg-cluster-metrics-managed-prometheus
  namespace: ${PG_NAMESPACE}
  labels:
    azure.workload.identity/use: "true"
    cnpg.io/cluster: ${PG_PRIMARY_CLUSTER_NAME}
spec:
  selector:
    matchLabels:
      azure.workload.identity/use: "true"
      cnpg.io/cluster: ${PG_PRIMARY_CLUSTER_NAME}
  podMetricsEndpoints:
    - port: metrics
EOF

Controleer of de podmonitor is gemaakt (let op het verschil in de groepsnaam).

kubectl --namespace $PG_NAMESPACE \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    get podmonitors.azmonitoring.coreos.com \
    -l cnpg.io/cluster=$PG_PRIMARY_CLUSTER_NAME \
    -o yaml

Optie A - Azure Monitor-werkruimte

Nadat u het Postgres-cluster en de podmonitor hebt geïmplementeerd, kunt u de metrische gegevens bekijken met behulp van Azure Portal in een Azure Monitor-werkruimte.

Optie B - Beheerd Grafana

Nadat u het Postgres-cluster en de podmonitoren hebt geïmplementeerd, kunt u ook een dashboard met metrische gegevens maken op het beheerde Grafana-exemplaar dat door het implementatiescript is gemaakt om de metrische gegevens te visualiseren die zijn geëxporteerd naar de Azure Monitor-werkruimte. U hebt toegang tot managed Grafana via Azure Portal. Navigeer naar het beheerde Grafana-exemplaar dat is gemaakt door het implementatiescript en selecteer de koppeling Eindpunt, zoals hier wordt weergegeven:

Als u de koppeling Eindpunt selecteert, wordt een nieuw browservenster geopend waarin u dashboards kunt maken op het beheerde Grafana-exemplaar. Volg de instructies voor het configureren van een Azure Monitor-gegevensbron. Vervolgens kunt u visualisaties toevoegen om een dashboard met metrische gegevens te maken vanuit het Postgres-cluster. Nadat u de verbinding met de gegevensbron hebt ingesteld, selecteert u in het hoofdmenu de optie Gegevensbronnen. U ziet nu een set opties voor gegevensbronnen voor de gegevensbronverbinding, zoals hier wordt weergegeven:

Selecteer in de optie Beheerde Prometheus de optie om een dashboard te maken om de dashboardeditor te openen. Nadat het editorvenster is geopend, selecteert u de optie Visualisatie toevoegen en selecteert u vervolgens de optie Beheerde Prometheus om door de metrische gegevens van het Postgres-cluster te bladeren. Nadat u de metrische gegevens hebt geselecteerd die u wilt visualiseren, selecteert u de knop Query's uitvoeren om de gegevens voor de visualisatie op te halen, zoals hier wordt weergegeven:

Selecteer het pictogram Opslaan om het deelvenster toe te voegen aan uw dashboard. U kunt andere panelen toevoegen door de knop Toevoegen te selecteren in de dashboardeditor en dit proces te herhalen om andere metrische gegevens te visualiseren. Als u de visualisaties voor metrische gegevens toevoegt, moet u iets hebben dat er als volgt uitziet:

Selecteer het pictogram Opslaan om uw dashboard op te slaan.

Volgende stappen

Contributors

Microsoft onderhoudt dit artikel. De volgende inzenders hebben het oorspronkelijk geschreven:

• Ken Kilty | Hoofd TPM
• Russell de Pina | Principal TPM
• Adrian Joian | Senior klanttechnicus
• Jenny Hayes | Senior Content Developer
• Carol Smith | Senior Content Developer
• Erin Schaffer | Inhoudsontwikkelaar 2
• Adam Sharif | Technisch Klantadviseur 2

Erkenning

Deze documentatie is gezamenlijk ontwikkeld met EnterpriseDB, de onderhouders van de CloudNativePG-operator. We danken Gabriele Bartolini voor het bekijken van eerdere concepten van dit document en het aanbieden van technische verbeteringen.