Tutorial: Bereitstellen des Daten-API-Generators in Azure Container Apps mit der Azure CLI

Artikel
05/02/2024

Der Daten-API-Generator kann schnell in Azure-Diensten wie Azure Container Apps als Teil Ihres Anwendungsstapels bereitgestellt werden. In diesem Tutorial verwenden Sie die Azure CLI, um allgemeine Aufgaben beim Bereitstellen des Daten-API-Generators in Azure zu automatisieren. Zunächst erstellen Sie ein Containerimage mit dem Daten-API-Generator und speichern es in Azure Container Registry. Anschließend stellen Sie das Containerimage in Azure Container Apps mit einer Unterstützung Azure SQL Datenbank bereit. Das gesamte Tutorial authentifiziert sich bei jeder Komponente mithilfe verwalteter Identitäten.

In diesem Tutorial:

Create einer verwalteten Identität mit rollenbasierten Zugriffssteuerungsberechtigungen
Bereitstellen Azure SQL mit dem AdventureWorksLT-Beispieldataset
Staging des Containerimages in Azure Container Registry
Bereitstellen von Azure Container App mit dem Containerimage des Daten-API-Generators

Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Voraussetzungen

Azure-Abonnement

Azure Cloud Shell
- Azure Cloud Shell ist eine interaktive Shellumgebung, die Sie über Ihren Browser verwenden können. Verwenden Sie diese Shell und ihre vorinstallierten Befehle, um den Code in diesem Artikel auszuführen, ohne etwas in Ihrer lokalen Umgebung installieren zu müssen. Starten von Azure Cloud Shell:
  - Wählen Sie in einem Code oder Befehlsblock in diesem Artikel ausprobieren aus. Wenn Sie Ausprobieren auswählen, wird der Code oder Befehl nicht automatisch in Cloud Shell kopiert.
  - Wechseln Sie zu https://shell.azure.com, oder wählen Sie Cloud Shell starten aus.
  - Wählen Sie Cloud Shell in der Menüleiste des Azure-Portal (https://portal.azure.com) aus.

Create Container-App

Erstellen Sie zunächst eine Azure Container Apps-instance mit einer systemseitig zugewiesenen verwalteten Identität. Dieser Identität werden schließlich rollenbasierte Zugriffssteuerungsberechtigungen für den Zugriff auf Azure SQL und Azure Container Registry gewährt.

Create eine universelle SUFFIX Variable, die später in diesem Tutorial für mehrere Ressourcennamen verwendet werden soll.
```
let SUFFIX=$RANDOM*$RANDOM
```
Create eine LOCATION Variable mit einer Azure-Region, die Sie in diesem Tutorial ausgewählt haben.
```
LOCATION="<azure-region>"
```
Hinweis

Wenn Sie beispielsweise in der Region "USA, Westen " bereitstellen möchten, verwenden Sie dieses Skript.
```
LOCATION="westus"
```
Verwenden Sie für eine Liste der unterstützten Regionen für das aktuelle Abonnement az account list-locations
```
az account list-locations --query "[].{Name:displayName,Slug:name}" --output table
```
Weitere Informationen finden Sie unter Azure-Regionen.
Create eine Variable namens RESOURCE_GROUP_NAME mit dem Namen der Ressourcengruppe. Für dieses Tutorial wird empfohlen msdocs-dab-*. Sie verwenden diesen Wert in diesem Tutorial mehrmals.
```
RESOURCE_GROUP_NAME="msdocs-dab$SUFFIX"    
```

Create eine neue Ressourcengruppe mit az group create.

az group create \
  --name $RESOURCE_GROUP_NAME \
  --location $LOCATION \
  --tag "source=msdocs-dab-tutorial"

Create Variablen namens API_CONTAINER_NAME und CONTAINER_ENV_NAME mit eindeutig generierten Namen für Ihre Azure Container Apps-instance. Sie verwenden diese Variablen im gesamten Tutorial.
```
API_CONTAINER_NAME="api$SUFFIX"
CONTAINER_ENV_NAME="env$SUFFIX"
```

Verwenden Sie az containerapp env create , um eine neue Azure Container Apps-Umgebung zu erstellen.

az containerapp env create \ 
  --resource-group $RESOURCE_GROUP_NAME \
  --name $CONTAINER_ENV_NAME \
  --logs-destination none \
  --location $LOCATION

Create eine neue Container-App mithilfe von mcr.microsoft.com/azure-databases/data-api-builder DAB-Containerimage und der az containerapp create Befehl. Diese Container-App wird erfolgreich ausgeführt, ist aber mit keiner Datenbank verbunden.

az containerapp create \ 
  --resource-group $RESOURCE_GROUP_NAME \
  --environment $CONTAINER_ENV_NAME \
  --name $API_CONTAINER_NAME \
  --image "mcr.microsoft.com/azure-databases/data-api-builder" \
  --ingress "external" \
  --target-port "5000" \
  --system-assigned

Rufen Sie den Prinzipalbezeichner der verwalteten Identität mithilfe az identity show von ab, und speichern Sie den Wert in einer Variablen mit dem Namen MANAGED_IDENTITY_PRINCIPAL_ID.
```
MANAGED_IDENTITY_PRINCIPAL_ID=$( \
  az containerapp show \ 
    --resource-group $RESOURCE_GROUP_NAME \
    --name $API_CONTAINER_NAME \
    --query "identity.principalId" \
    --output "tsv" \
)
```
Tipp

Sie können die Ausgabe dieses Befehls jederzeit überprüfen.
```
echo $MANAGED_IDENTITY_PRINCIPAL_ID
```

Zuweisen von Berechtigungen

Weisen Sie nun der systemseitig zugewiesenen verwalteten Identität Berechtigungen zum Lesen von Daten aus Azure SQL und Azure Container Registry zu. Weisen Sie Außerdem Ihre Identitätsberechtigungen zu, um in Azure Container Registry zu schreiben.

Create eine Variable namensRESOURCE_GROUP_ID, um den Bezeichner der Ressourcengruppe zu speichern. Rufen Sie den Bezeichner mithilfe von az group showab. Sie verwenden diese Variable in diesem Tutorial mehrmals.
```
RESOURCE_GROUP_ID=$( \
  az group show \
    --name $RESOURCE_GROUP_NAME \
    --query "id" \
    --output "tsv" \
)
```
Tipp

Sie können die Ausgabe dieses Befehls jederzeit überprüfen.
```
echo $RESOURCE_GROUP_ID
```

Verwenden Sie az role assignment create , um Ihrem Konto die AcrPush-Rolle zuzuweisen, damit Sie Container per Push an Azure Container Registry.

CURRENT_USER_PRINCIPAL_ID=$( \
  az ad signed-in-user show \
    --query "id" \
    --output "tsv" \
)

# AcrPush
az role assignment create \
  --assignee $CURRENT_USER_PRINCIPAL_ID \
  --role "8311e382-0749-4cb8-b61a-304f252e45ec" \
  --scope $RESOURCE_GROUP_ID

Weisen Sie Der verwalteten Identität az role assignment create mithilfe erneut die Rolle AcrPull zu. Diese Zuweisung ermöglicht es der verwalteten Identität, Containerimages aus Azure Container Registry zu pullen. Die verwaltete Identität wird schließlich einer Azure Container Apps-instance zugewiesen.
```
# AcrPull    
az role assignment create \
  --assignee $MANAGED_IDENTITY_PRINCIPAL_ID \
  --role "7f951dda-4ed3-4680-a7ca-43fe172d538d" \
  --scope $RESOURCE_GROUP_ID
```

Bereitstellen einer Datenbank

Stellen Sie als Nächstes einen neuen Server und eine neue Datenbank im Azure SQL-Dienst bereit. Die Datenbank verwendet das AdventureWorksLT-Beispieldataset .

Create eine Variable namens SQL_SERVER_NAME mit einem eindeutig generierten Namen für Ihre Azure SQL Server-instance. Sie verwenden diese Variable weiter unten in diesem Abschnitt.
```
SQL_SERVER_NAME="srvr$SUFFIX"
```

Create mit az sql server createeine neue Azure SQL Serverressource aus. Konfigurieren Sie die verwaltete Identität als Administrator dieses Servers.

az sql server create \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $SQL_SERVER_NAME \
  --location $LOCATION \
  --enable-ad-only-auth \
  --external-admin-principal-type "User" \
  --external-admin-name $API_CONTAINER_NAME \
  --external-admin-sid $MANAGED_IDENTITY_PRINCIPAL_ID

Verwenden Sie az sql server firewall-rule create , um eine Firewallregel zu erstellen, um den Zugriff von Azure-Diensten zuzulassen.

az sql server firewall-rule create \
  --resource-group $RESOURCE_GROUP_NAME \
  --server $SQL_SERVER_NAME \
  --name "AllowAzure" \
  --start-ip-address "0.0.0.0" \
  --end-ip-address "0.0.0.0"

Verwenden Sie az sql db create , um eine Datenbank innerhalb des Azure SQL-Servers namens adventureworkszu erstellen. Konfigurieren Sie die Datenbank für die Verwendung der AdventureWorksLT Beispieldaten.
```
az sql db create \
  --resource-group $RESOURCE_GROUP_NAME \
  --server $SQL_SERVER_NAME \
  --name "adventureworks" \
  --sample-name "AdventureWorksLT"
```
Create Eine Variable namens SQL_CONNECTION_STRING mit dem Verbindungszeichenfolge für die adventureworks Datenbank in Ihrem Azure SQL Server instance. Erstellen Sie die Verbindungszeichenfolge mit dem vollqualifizierten Domänennamen des Servers mithilfe az sql server showvon . Sie verwenden diese Variable später in diesem Tutorial.
```
SQL_SERVER_ENDPOINT=$( \
  az sql server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $SQL_SERVER_NAME \
    --query "fullyQualifiedDomainName" \
    --output "tsv" \
)

SQL_CONNECTION_STRING="Server=$SQL_SERVER_ENDPOINT;Database=adventureworks;Encrypt=true;Authentication=Active Directory Default;"
```
Tipp

Sie können die Ausgabe dieses Befehls jederzeit überprüfen.
```
echo $SQL_CONNECTION_STRING
```

Erstellen des Containerimage

Erstellen Sie als Nächstes ein Containerimage mithilfe einer Dockerfile-Datei. Stellen Sie dann dieses Containerimage in einem neu erstellten Azure Container Registry instance bereit.

Create eine Variable namens CONTAINER_REGISTRY_NAME mit einem eindeutig generierten Namen für Ihre Azure Container Registry instance. Sie verwenden diese Variable weiter unten in diesem Abschnitt.
```
CONTAINER_REGISTRY_NAME="reg$SUFFIX"
```

Create mithilfe von az acr createeine neue Azure Container Registry instance aus.

az acr create \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $CONTAINER_REGISTRY_NAME \
  --sku "Standard" \
  --location $LOCATION \
  --admin-enabled false

Create eine mehrstufige Dockerfile-Datei namens Dockerfile. Implementieren Sie diese Schritte in der Datei.
- Verwenden des mcr.microsoft.com/dotnet/sdk Containerimages als Basis der Buildphase
- Installieren Sie die DAB CLI.
- Create eine Konfigurationsdatei für eine SQL-Datenbankverbindung (mssql) mit der DATABASE_CONNECTION_STRING Umgebungsvariablen als Verbindungszeichenfolge.
- Create eine Entität namensProduct, die der SalesLT.Product Tabelle zugeordnet ist.
- Kopieren Sie die Konfigurationsdatei in das endgültige mcr.microsoft.com/azure-databases/data-api-builder Containerimage.
```
FROM mcr.microsoft.com/dotnet/sdk:6.0-cbl-mariner2.0 AS build

WORKDIR /config

RUN dotnet new tool-manifest

RUN dotnet tool install Microsoft.DataApiBuilder

RUN dotnet tool run dab -- init --database-type "mssql" --connection-string "@env('DATABASE_CONNECTION_STRING')"

RUN dotnet tool run dab -- add Product --source "SalesLT.Product" --permissions "anonymous:read"

FROM mcr.microsoft.com/azure-databases/data-api-builder

COPY --from=build /config /App
```

Erstellen Sie die Dockerfile-Datei mit als Azure Container Registry Taskaz acr build.

az acr build \
  --registry $CONTAINER_REGISTRY_NAME \
  --image adventureworkslt-dab:latest \
  --image adventureworkslt-dab:{{.Run.ID}} \
  --file Dockerfile \
  .

Verwenden Sie az acr show , um den Endpunkt für die Containerregistrierung abzurufen und in einer Variablen mit dem Namen CONTAINER_REGISTRY_LOGIN_SERVERzu speichern.
```
CONTAINER_REGISTRY_LOGIN_SERVER=$( \
  az acr show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CONTAINER_REGISTRY_NAME \
    --query "loginServer" \
    --output "tsv" \
)
```
Tipp

Sie können die Ausgabe dieses Befehls jederzeit überprüfen.
```
echo $CONTAINER_REGISTRY_LOGIN_SERVER
```

Bereitstellen eines Containerimages

Aktualisieren Sie schließlich die Azure Container-App mit dem neuen benutzerdefinierten Containerimage und den Anmeldeinformationen. Testen Sie die ausgeführte Anwendung, um ihre Konnektivität mit der Datenbank zu überprüfen.

Konfigurieren Sie die Container-App für die Verwendung der Containerregistrierung mit az containerapp registry set.

az containerapp registry set \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $API_CONTAINER_NAME \
  --server $CONTAINER_REGISTRY_LOGIN_SERVER \
  --identity "system"

Verwenden Sie az containerapp secret set , um ein Geheimnis mit dem Namen conn-string mit dem Azure SQL Verbindungszeichenfolge zu erstellen.
```
az containerapp secret set \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $API_CONTAINER_NAME \
  --secrets conn-string="$SQL_CONNECTION_STRING"
```
Wichtig

Dieser Verbindungszeichenfolge enthält keinen Benutzernamen oder Kennwörter. Der Verbindungszeichenfolge verwendet die verwaltete Identität für den Zugriff auf die Azure SQL-Datenbank. Dies macht es sicher, die Verbindungszeichenfolge als Geheimnis auf dem Host zu verwenden.
Aktualisieren Sie die Container-App mit Ihrem neuen benutzerdefinierten Containerimage mithilfe von az containerapp update. Legen Sie die Umgebungsvariable DATABASE_CONNECTION_STRING so fest, dass sie aus dem zuvor erstellten conn-string Geheimnis liest.
```
az containerapp update \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $API_CONTAINER_NAME \
  --image "$CONTAINER_REGISTRY_LOGIN_SERVER/adventureworkslt-dab:latest" \
  --set-env-vars DATABASE_CONNECTION_STRING=secretref:conn-string
```
Rufen Sie den vollqualifizierten Domänennamen der neuesten Revision in der ausgeführten Container-App mithilfe az containerapp showvon ab. Speichern Sie diesen Wert in einer Variablen mit dem Namen APPLICATION_URL.
```
APPLICATION_URL=$( \
  az containerapp show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $API_CONTAINER_NAME \
    --query "properties.latestRevisionFqdn" \
    --output "tsv" \
)
```
Tipp

Sie können die Ausgabe dieses Befehls jederzeit überprüfen.
```
echo $APPLICATION_URL
```
Navigieren Sie zur URL, und testen Sie die Product REST-API.
```
echo "https://$APPLICATION_URL/api/Product"
```
Warnung

Die Bereitstellung kann bis zu einer Minute dauern. Wenn keine erfolgreiche Antwort angezeigt wird, warten Sie, und aktualisieren Sie Ihren Browser.

Bereinigen von Ressourcen

Wenn Sie die Beispielanwendung oder -ressourcen nicht mehr benötigen, entfernen Sie die entsprechende Bereitstellung und alle Ressourcen.

az group delete \
  --name $RESOURCE_GROUP_NAME

Nächster Schritt

Verwenden von Application Insights mit dem Daten-API-Generator

Freigeben über