Condividi tramite

Esercitazione: Distribuire Data API Builder nelle Azure Container Apps con Azure CLI

Il generatore di API dati può essere distribuito rapidamente nei servizi di Azure, ad esempio App contenitore di Azure, come parte dello stack di applicazioni. In questa esercitazione si usa l'interfaccia della riga di comando di Azure per automatizzare le attività comuni durante la distribuzione di Generatore API dati in Azure. Prima di tutto, si compila un'immagine del contenitore con Il generatore di API dati e la si archivia in Registro Azure Container. Si distribuisce quindi l'immagine del contenitore in App Azure Container con un database SQL di Azure di backup. L'intera esercitazione autentica ogni componente utilizzando identità gestite.

In questa esercitazione, farai:

  • Creare un'identità gestita con autorizzazioni di controllo degli accessi in base al ruolo
  • Distribuire Azure SQL con il set di dati AdventureWorksLT di esempio
  • Preparare l'immagine del contenitore nel Azure Container Registry
  • Distribuire l'app Contenitore di Azure con l'immagine del contenitore del generatore di API dati

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Prerequisiti

  • Sottoscrizione di Azure
  • Azure Cloud Shell
    • Azure Cloud Shell è un ambiente shell interattivo che è possibile usare tramite il browser. Usare questa shell e i relativi comandi preinstallati per eseguire il codice in questo articolo, senza dover installare alcun elemento nell'ambiente locale. Per avviare Azure Cloud Shell:
      • Selezionare Prova in un codice o in un blocco di comandi all'interno di questo articolo. Se si seleziona Prova , il codice o il comando non vengono copiati automaticamente in Cloud Shell.
      • Passare a https://shell.azure.como selezionare Avvia Cloud Shell.
      • Selezionare Cloud Shell nella barra dei menu del portale di Azure (https://portal.azure.com)

Creare un'app contenitore

Creare prima di tutto un'istanza di App Contenitore di Azure con un'identità gestita assegnata dal sistema. Questa identità viene infine concessa le autorizzazioni di controllo degli accessi in base al ruolo per accedere ad Azure SQL e a Azure Container Registry.

  1. Creare una variabile universale SUFFIX da usare per più nomi di risorse più avanti in questa esercitazione.

    let SUFFIX=$RANDOM*$RANDOM

  2. Creare una variabile con un'area LOCATION di Azure selezionata da usare in questa esercitazione.

    LOCATION="<azure-region>"

    Annotazioni

    Ad esempio, se si vuole eseguire la distribuzione nell'area Stati Uniti occidentali , usare questo script.

    LOCATION="westus"

    Per un elenco delle aree supportate per la sottoscrizione corrente, usare az account list-locations

    az account list-locations --query "[].{Name:displayName,Slug:name}" --output table

    Per altre informazioni, vedere aree di Azure.

  3. Creare una variabile denominata RESOURCE_GROUP_NAME con il nome del gruppo di risorse. Per questa esercitazione, raccomandiamo msdocs-dab-*. Questo valore viene usato più volte in questa esercitazione.

    RESOURCE_GROUP_NAME="msdocs-dab$SUFFIX"

  4. Creare un nuovo gruppo di risorse usando az group create.

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

  5. Creare variabili denominate API_CONTAINER_NAME e CONTAINER_ENV_NAME con nomi generati in modo univoco per l'istanza di App Contenitore di Azure. Queste variabili vengono usate durante l'esercitazione.

    API_CONTAINER_NAME="api$SUFFIX"
CONTAINER_ENV_NAME="env$SUFFIX"

  6. Usare az containerapp env create per creare un nuovo ambiente di App Azure Container.

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

  7. Creare una nuova app contenitore usando l'immagine del mcr.microsoft.com/azure-databases/data-api-builder contenitore DAB e il az containerapp create comando . Questa app contenitore viene eseguita correttamente, ma non è connessa ad alcun database.

    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

  8. Ottenere l'identificatore principale dell'identità gestita usando az identity show e archiviare il valore in una variabile denominata 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" \
)

    Suggerimento

    È sempre possibile controllare l'output di questo comando.

    echo $MANAGED_IDENTITY_PRINCIPAL_ID

Assegnare autorizzazioni

Assegnare ora le autorizzazioni di identità gestita assegnate dal sistema per leggere i dati da Azure SQL e registro Azure Container. Assegna anche le autorizzazioni di identità per scrivere nel Registro dei container di Azure.

  1. Creare una variabile denominata RESOURCE_GROUP_ID per archiviare l'identificatore del gruppo di risorse. Ottenere l'identificatore usando az group show. Questa variabile viene usata più volte in questa esercitazione.

    RESOURCE_GROUP_ID=$( \
  az group show \
    --name $RESOURCE_GROUP_NAME \
    --query "id" \
    --output "tsv" \
)

    Suggerimento

    È sempre possibile controllare l'output di questo comando.

    echo $RESOURCE_GROUP_ID

  2. Usare az role assignment create per assegnare il ruolo AcrPush all'account in modo da poter eseguire il push dei contenitori in Registro Azure Container.

    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

  3. Assegnare di nuovo il ruolo AcrPull all'identità gestita usando az role assignment create. Questa assegnazione consente all'identità gestita di recuperare le immagini del container dall'Azure Container Registry. L'identità gestita viene infine assegnata a un'istanza di App Contenitore di Azure.

    # AcrPull    
az role assignment create \
  --assignee $MANAGED_IDENTITY_PRINCIPAL_ID \
  --role "7f951dda-4ed3-4680-a7ca-43fe172d538d" \
  --scope $RESOURCE_GROUP_ID

Distribuire il database

Distribuire quindi un nuovo server e un nuovo database nel servizio SQL di Azure. Il database usa il set di dati di esempio AdventureWorksLT .

  1. Creare una variabile denominata SQL_SERVER_NAME con un nome generato in modo univoco per l'istanza di SQL Server di Azure. Questa variabile verrà usata più avanti in questa sezione.

    SQL_SERVER_NAME="srvr$SUFFIX"

  2. Creare una nuova risorsa del server SQL di Azure usando az sql server create. Configurare l'identità gestita come amministratore di questo server.

    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

  3. Usare az sql server firewall-rule create per creare una regola del firewall per consentire l'accesso dai servizi di Azure.

    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"

  4. Usare az sql db create per creare un database all'interno del server SQL di Azure denominato adventureworks. Configurare il database per l'uso dei AdventureWorksLT dati di esempio.

    az sql db create \
  --resource-group $RESOURCE_GROUP_NAME \
  --server $SQL_SERVER_NAME \
  --name "adventureworks" \
  --sample-name "AdventureWorksLT"

  5. Creare una variabile denominata SQL_CONNECTION_STRING con la stringa di connessione per il database nell'istanza adventureworks di SQL Server di Azure. Costruire la stringa di connessione con il nome di dominio completo del server usando az sql server show. Questa variabile verrà usata più avanti in questa esercitazione.

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

    Suggerimento

    È sempre possibile controllare l'output di questo comando.

    echo $SQL_CONNECTION_STRING

Compilare l'immagine del contenitore

Compilare quindi un'immagine del contenitore usando un Dockerfile. Distribuire quindi l'immagine del contenitore in un'istanza di Registro Azure Container appena creata.

  1. Creare una variabile denominata CONTAINER_REGISTRY_NAME con un nome generato in modo univoco per l'istanza di Registro Azure Container. Questa variabile verrà usata più avanti in questa sezione.

    CONTAINER_REGISTRY_NAME="reg$SUFFIX"

  2. Creare una nuova istanza di Registro Azure Container usando az acr create.

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

  3. Creare un Dockerfile a più fasi denominato Dockerfile. Nel file implementare questi passaggi.

    • Usare l'immagine del mcr.microsoft.com/dotnet/sdk contenitore come base della fase di compilazione

    • Installare il DAB CLI.

    • Creare un file di configurazione per una connessione al database SQL (mssql) usando la DATABASE_CONNECTION_STRING variabile di ambiente come stringa di connessione.

    • Creare un'entità denominata Product mappata alla tabella SalesLT.Product.

    • Copiare il file di configurazione nell'immagine del contenitore finale mcr.microsoft.com/azure-databases/data-api-builder .

    FROM mcr.microsoft.com/dotnet/sdk:8.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

  4. Compilare il Dockerfile come attività di Registro Azure Container usando az acr build.

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

  5. Usare az acr show per ottenere l'endpoint per il registro contenitori e archiviarlo in una variabile denominata CONTAINER_REGISTRY_LOGIN_SERVER.

    CONTAINER_REGISTRY_LOGIN_SERVER=$( \
  az acr show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CONTAINER_REGISTRY_NAME \
    --query "loginServer" \
    --output "tsv" \
)

    Suggerimento

    È sempre possibile controllare l'output di questo comando.

    echo $CONTAINER_REGISTRY_LOGIN_SERVER

Distribuire l'immagine del contenitore

Aggiornare infine l'app Azure Container con la nuova immagine e le credenziali del contenitore personalizzate. Testare l'applicazione in esecuzione per convalidare la connettività al database.

  1. Configurare l'app contenitore per l'uso del registro dei contenitori tramite az containerapp registry set.

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

  2. Usare az containerapp secret set per creare un segreto denominato conn-string con la stringa di connessione SQL di Azure.

    az containerapp secret set \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $API_CONTAINER_NAME \
  --secrets conn-string="$SQL_CONNECTION_STRING"

    Importante

    Questa stringa di connessione non include nome utente o password. La stringa di connessione usa l'identità gestita per accedere al database SQL di Azure. In tal modo, è sicuro usare la stringa di connessione come un segreto nell'host.

  3. Aggiornare l'app contenitore con la nuova immagine del contenitore personalizzata usando az containerapp update. Impostare la variabile di ambiente DATABASE_CONNECTION_STRING per leggere dal segreto conn-string precedentemente creato.

    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

  4. Ottieni il nome di dominio completo della revisione più recente nell'app container attualmente in esecuzione usando az containerapp show. Archiviare tale valore in una variabile denominata APPLICATION_URL.

    APPLICATION_URL=$( \
  az containerapp show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $API_CONTAINER_NAME \
    --query "properties.latestRevisionFqdn" \
    --output "tsv" \
)

    Suggerimento

    È sempre possibile controllare l'output di questo comando.

    echo $APPLICATION_URL

  5. Passare all'URL e testare l'API Product REST.

    echo "https://$APPLICATION_URL/api/Product"

    Avvertimento

    La distribuzione può richiedere fino a un minuto. Se non viene visualizzata una risposta corretta, attendere e aggiornare il browser.

Pulire le risorse

Quando l'applicazione o le risorse di esempio non sono più necessarie, rimuovere la distribuzione corrispondente e tutte le risorse.

az group delete \
  --name $RESOURCE_GROUP_NAME

Passo successivo

Usare Application Insights con Il generatore di API dati

  • Last updated on