Bereitstellen des Daten-API-Generators in Azure Kubernetes Service

Mit Azure Kubernetes Service (AKS) können Sie den Daten-API-Generator in einem verwalteten Kubernetes-Cluster zusammen mit ihren anderen Workloads ausführen. Dieser Leitfaden führt Sie durch das Erstellen eines benutzerdefinierten Containerimages, das Ihre Konfigurationsdatei enthält, das Pushen an die Azure Container Registry (ACR) und die Bereitstellung in AKS mit einem Kubernetes-Manifest.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Kostenlos ein Konto erstellen.
Azure CLI installiert
kubectl installiert
Docker installiert
CLI des Daten-API-Erstellers. Installieren der CLI
Ein bestehender AKS-Cluster. Erstellen eines AKS-Clusters
Eine vorhandene unterstützte Datenbank, die von AKS erreichbar ist

Erstellen der Konfigurationsdatei

Erstellen Sie ein lokales Verzeichnis für Ihre Konfigurationsdateien.
Initialisieren Sie eine Basiskonfigurationsdatei mithilfe von dab init. Verwenden Sie die @env() Funktion für die Verbindungszeichenfolge, sodass der geheime Schlüssel zur Laufzeit eingefügt wird und nicht in das Bild integriert ist.
```
dab init \
  --database-type mssql \
  --connection-string "@env('DATABASE_CONNECTION_STRING')"
```
Fügen Sie mindestens eine Entität mithilfe von dab add. Wiederholen Sie diesen Vorgang für jede Tabelle oder Ansicht, die Sie verfügbar machen möchten.
```
dab add Books \
  --source dbo.Books \
  --permissions "anonymous:read"
```
Überprüfen Sie dab-config.json, bevor Sie fortfahren.

Erstellen und Übertragen eines benutzerdefinierten Containerimages

Erstellen Sie ein Bild, das dab-config.json bei /App/dab-config.json umfasst.

Erstellen Sie eine Azure-Containerregistrierung, wenn Sie noch keines haben.

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

Erstellen Sie ein Objekt Dockerfile im selben Verzeichnis wie dab-config.json.

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

Erstellen und übertragen Sie das Image mithilfe von ACR-Aufgaben.

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

Beachten Sie den vollständigen Bildverweis: <registry-name>.azurecr.io/dab:latest.

Verbinden von AKS mit ACR

Gewähren Sie Ihrem AKS-Cluster Pull-Zugriff auf das Registry.

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

Speichern der Verbindungszeichenfolge als Kubernetes-Schlüssel

Speichern Sie die Datenbankverbindungszeichenfolge als Kubernetes-Schlüssel, damit sie sich nie in der Manifestdatei befindet.

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

Warnung

Platzieren Sie Verbindungszeichenfolgen niemals direkt in Kubernetes-Manifestdateien oder Containerimages. Verwenden Sie geheime Schlüssel oder Azure Key Vault.

Erstellen des Kubernetes-Manifests

Erstellen Sie eine Datei namens dab-deployment.yaml mit folgendem Inhalt. Ersetzen Sie <registry-name> durch Ihren ACR-Namen.

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

Hinweis

Die readinessProbe und livenessProbe nutzen den DAB-/health-Endpunkt. Weitere Informationen finden Sie unter Gesundheitsprüfungen.

Bereitstellen in AKS

Rufen Sie Anmeldeinformationen für Ihren Cluster ab.

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

Wenden Sie das Manifest an.
```
kubectl apply -f dab-deployment.yaml
```
Sehen Sie sich das Rollout an, bis die Pods einsatzbereit sind.
```
kubectl rollout status deployment/dab
```
Rufen Sie die externe IP-Adresse ab, die dem Dienst zugewiesen ist.
```
kubectl get service dab-service
```
In EXTERNAL-IP der Spalte wird die öffentliche IP-Adresse angezeigt. Lassen Sie eine Minute für die Bereitstellung des Load Balancers einzuplanen.

Überprüfen Sie die Bereitstellung

Navigieren Sie zu http://<external-ip>/health. Eine gesunde Antwort sieht wie folgt aus:
```
{
  "status": "healthy",
  "version": "2.0.0",
  "app-name": "dab_oss_2.0.0"
}
```
Testen Sie einen Entitätsendpunkt.
```
curl http://<external-ip>/api/Books
```

Skalieren der Bereitstellung

Ändern Sie die Replikatanzahl so, dass sie horizontal skaliert wird.

kubectl scale deployment/dab --replicas=4

Oder aktualisieren Sie spec.replicas in dab-deployment.yaml und wenden Sie es erneut an.

Bereinigen von Ressourcen

Entfernen Sie die Bereitstellung und den Dienst, wenn sie nicht mehr benötigt werden.

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

Um den AKS-Cluster und die Registrierung zu löschen, entfernen Sie die Ressourcengruppe.

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

Feedback

War diese Seite hilfreich?

Last updated on 2026-04-02