Condividi tramite

Distribuire Generatore API dati nel servizio Azure Kubernetes

Il servizio Azure Kubernetes consente di eseguire Generatore API dati in un cluster Kubernetes gestito insieme agli altri carichi di lavoro. Questa guida illustra come creare un'immagine di contenitore personalizzata che include il file di configurazione, pubblicarla in Azure Container Registry e distribuirla in Azure Kubernetes Service con un manifesto Kubernetes.

Prerequisiti

Compilare il file di configurazione

  1. Creare una directory locale per i file di configurazione.

  2. Inizializzare un file di configurazione di base usando dab init. Usare la @env() funzione per la stringa di connessione in modo che il segreto venga inserito in fase di esecuzione, non inserito nell'immagine.

    dab init \
  --database-type mssql \
  --connection-string "@env('DATABASE_CONNECTION_STRING')"

  3. Aggiungere almeno un'entità usando dab add. Ripetere per ogni tabella o vista da esporre.

    dab add Books \
  --source dbo.Books \
  --permissions "anonymous:read"

  4. Esaminare dab-config.json prima di continuare.

Compilare ed eseguire il push di un'immagine del contenitore personalizzata

Compilare un'immagine che include dab-config.json in /App/dab-config.json.

  1. Creare un Registro Azure Container se non ne è già disponibile uno.

    az acr create \
  --resource-group <resource-group> \
  --name <registry-name> \
  --sku Basic \
  --admin-enabled true

  2. Creare un oggetto Dockerfile nella stessa directory di dab-config.json.

    FROM mcr.microsoft.com/azure-databases/data-api-builder:latest
COPY dab-config.json /App/dab-config.json

  3. Compilare e inviare l'immagine utilizzando le ACR Tasks.

    az acr build \
  --registry <registry-name> \
  --image dab:latest \
  .

  4. Si noti il riferimento completo all'immagine: <registry-name>.azurecr.io/dab:latest.

Collegare AKS ad ACR

Concedere al cluster del servizio Azure Kubernetes l'accesso pull al Registro di sistema.

az aks update \
  --name <cluster-name> \
  --resource-group <resource-group> \
  --attach-acr <registry-name>

Archiviare la stringa di connessione come segreto Kubernetes

Archiviare la stringa di connessione del database come segreto di Kubernetes in modo che non sia mai nel file manifesto.

kubectl create secret generic dab-secrets \
  --from-literal=DATABASE_CONNECTION_STRING="<your-connection-string>"

Avviso

Non inserire mai le stringhe di connessione direttamente nei file manifesto di Kubernetes o nelle immagini del contenitore. Usare segreti o Azure Key Vault.

Creare il manifesto Kubernetes

Creare un file denominato dab-deployment.yaml con il contenuto seguente. Sostituire <registry-name> con il nome del registro ACR.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dab
  labels:
    app: dab
spec:
  replicas: 2
  selector:
    matchLabels:
      app: dab
  template:
    metadata:
      labels:
        app: dab
    spec:
      containers:
        - name: dab
          image: <registry-name>.azurecr.io/dab:latest
          ports:
            - containerPort: 5000
          env:
            - name: DATABASE_CONNECTION_STRING
              valueFrom:
                secretKeyRef:
                  name: dab-secrets
                  key: DATABASE_CONNECTION_STRING
          readinessProbe:
            httpGet:
              path: /health
              port: 5000
            initialDelaySeconds: 5
            periodSeconds: 10
          livenessProbe:
            httpGet:
              path: /health
              port: 5000
            initialDelaySeconds: 15
            periodSeconds: 20
---
apiVersion: v1
kind: Service
metadata:
  name: dab-service
spec:
  selector:
    app: dab
  ports:
    - protocol: TCP
      port: 80
      targetPort: 5000
  type: LoadBalancer

Annotazioni

e readinessProbelivenessProbe usano l'endpoint DAB /health . Per altre informazioni, vedere Controlli di integrità.

Distribuire nel servizio Azure Kubernetes

  1. Ottenere le credenziali per il cluster.

    az aks get-credentials \
  --resource-group <resource-group> \
  --name <cluster-name>

  2. Applicare il manifesto.

    kubectl apply -f dab-deployment.yaml

  3. Controllare la distribuzione fino a quando i pod non sono pronti.

    kubectl rollout status deployment/dab

  4. Ottenere l'indirizzo IP esterno assegnato al servizio.

    kubectl get service dab-service

    La EXTERNAL-IP colonna mostra l'indirizzo IP pubblico. Attendere un minuto per il provisioning del bilanciatore di carico.

Verificare la distribuzione

  1. Sfoglia fino a http://<external-ip>/health. Una risposta adeguata si presenta così:

    {
  "status": "healthy",
  "version": "2.0.0",
  "app-name": "dab_oss_2.0.0"
}

  2. Testare un endpoint di entità.

    curl http://<external-ip>/api/Books

Scalare l'implementazione

Modificare il conteggio delle repliche per scalare orizzontalmente.

kubectl scale deployment/dab --replicas=4

Oppure aggiorna spec.replicas in dab-deployment.yaml e riapplicalo.

Pulire le risorse

Rimuovere la distribuzione e il servizio quando non sono più necessari.

kubectl delete -f dab-deployment.yaml
kubectl delete secret dab-secrets

Per eliminare il cluster AKS e il registro, rimuovere il gruppo di risorse.

az group delete \
  --name <resource-group> \
  --yes --no-wait

Contenuti correlati

  • Last updated on