Guida introduttiva: Usare la configurazione di app Azure in servizio Azure Kubernetes

Articolo
04/30/2024

In Kubernetes si configurano i pod per l'uso della configurazione da Config Mappe. Consente di separare la configurazione dalle immagini del contenitore, rendendo le applicazioni facilmente portabili. app Azure provider Kubernetes di configurazione può costruire config Mappe e segreti dai riferimenti a key-values e Key Vault in app Azure Configuration. Consente di sfruttare app Azure Configurazione per l'archiviazione centralizzata e la gestione della configurazione senza apportare modifiche al codice dell'applicazione.

Un oggetto ConfigMap può essere utilizzato come variabili di ambiente o come file montato. In questa guida introduttiva si incorpora app Azure provider Kubernetes di configurazione in un carico di lavoro servizio Azure Kubernetes in cui si esegue una semplice ASP.NET configurazione dell'app Core che usa da un file JSON.

Suggerimento

Vedere le opzioni per i carichi di lavoro ospitati in Kubernetes per accedere alla configurazione di app Azure.

Nota

Questa guida introduttiva illustra come configurare il provider Kubernetes di configurazione app Azure. Facoltativamente, è possibile usare i comandi seguenti dell'interfaccia della riga di comando per sviluppatori di Azure con il modello per effettuare il azure-appconfig-aks provisioning delle risorse di Azure e distribuire l'applicazione di esempio usata da questa guida introduttiva. Per altre informazioni su questo modello, visitare il repository azure-appconfig-aks in GitHub.

azd init -t azure-appconfig-aks
azd up

Prerequisiti

Archivio Configurazione app. Creare un archivio.
Un Registro Azure Container. Creare un registro.
Un cluster servizio Azure Kubernetes (servizio Azure Kubernetes) autorizzato a eseguire il pull delle immagini dal Registro Azure Container. Creare un cluster del servizio Azure Kubernetes.
.NET SDK 6.0 o versione successiva
Interfaccia della riga di comando di Azure
Docker Desktop
Timone
kubectl

Creare un'applicazione in esecuzione nel servizio Azure Kubernetes

In questa sezione si creerà una semplice applicazione Web ASP.NET Core in esecuzione in servizio Azure Kubernetes (servizio Azure Kubernetes). L'applicazione legge la configurazione da un file JSON locale. Nella sezione successiva si abiliterà l'uso della configurazione da app Azure Configurazione senza modificare il codice dell'applicazione. Se si dispone già di un'applicazione del servizio Azure Kubernetes che legge la configurazione da un file, ignorare questa sezione e passare a Usare Configurazione app provider Kubernetes. È sufficiente assicurarsi che il file di configurazione generato dal provider corrisponda al percorso del file usato dall'applicazione.

Creare un'applicazione

Usare l'interfaccia della riga di comando di .NET ed eseguire il comando seguente per creare un nuovo progetto di app Web ASP.NET Core in una nuova directory MyWebApp :
```
dotnet new webapp --output MyWebApp --framework net6.0
```

Aprire Index.cshtml nella directory Pages e aggiornare il contenuto con il codice seguente.

@page
@model IndexModel
@using Microsoft.Extensions.Configuration
@inject IConfiguration Configuration
@{
    ViewData["Title"] = "Home page";
}

<style>
    h1 {
        color: @Configuration["Settings:FontColor"];
    }
</style>

<div class="text-center">
    <h1>@Configuration["Settings:Message"]</h1>
</div>

Creare una directory di configurazione nella radice del progetto e aggiungervi un file mysettings.json con il contenuto seguente.
```
{
  "Settings": {
    "FontColor": "Black",
    "Message": "Message from the local configuration"
  }
}
```

Aprire program.cs e aggiungere il file JSON all'origine di configurazione chiamando il AddJsonFile metodo .

// Existing code in Program.cs
// ... ...

// Add a JSON configuration source 
builder.Configuration.AddJsonFile("config/mysettings.json", reloadOnChange: true, optional: false);

var app = builder.Build();

// The rest of existing code in program.cs
// ... ...

Distribuire l'applicazione in un contenitore

Eseguire il comando dotnet publish per compilare l'app in modalità di rilascio e creare gli asset nella directory pubblicata .
```
dotnet publish -c Release -o published
```
Creare un file denominato Dockerfile nella radice della directory del progetto, aprirlo in un editor di testo e immettere il contenuto seguente. Un Dockerfile è un file di testo che non ha un'estensione e che viene usato per creare un'immagine del contenitore.
```
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
WORKDIR /app
COPY published/ ./
ENTRYPOINT ["dotnet", "MyWebApp.dll"]
```
Compilare un'immagine del contenitore denominata aspnetapp eseguendo il comando seguente.
```
docker build --tag aspnetapp .
```

Eseguire il push delle immagini in Registro Azure Container

Eseguire il comando az acr login per accedere al registro contenitori. Nell'esempio seguente viene registrato un registro denominato myregistry. Sostituire il nome del Registro di sistema con il nome dell'utente.
```
az acr login --name myregistry
```
Il comando restituisce Login Succeeded una volta completato l'accesso.
Usare il tag Docker per creare un tag myregistry.azurecr.io/aspnetapp:v1 per l'immagine aspnetapp.
```
docker tag aspnetapp myregistry.azurecr.io/aspnetapp:v1
```
Suggerimento

Per esaminare l'elenco delle immagini e dei tag Docker esistenti, eseguire docker image ls. In questo scenario dovrebbero essere visualizzate almeno due immagini: aspnetapp e myregistry.azurecr.io/aspnetapp.
Usare docker push per caricare l'immagine nel registro contenitori. Ad esempio, il comando seguente esegue il push dell'immagine in un repository denominato aspnetapp con tag v1 nel Registro di sistema myregistry.
```
docker push myregistry.azurecr.io/aspnetapp:v1
```

Distribuire l'applicazione

Creare una directory Deployment nella directory radice del progetto.

Aggiungere un file deployment.yaml alla directory Deployment con il contenuto seguente per creare una distribuzione. Sostituire il valore di template.spec.containers.image con l'immagine creata nel passaggio precedente.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aspnetapp-demo
  labels:
    app: aspnetapp-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aspnetapp-demo
  template:
    metadata:
      labels:
        app: aspnetapp-demo
    spec:
      containers:
      - name: aspnetapp
        image: myregistry.azurecr.io/aspnetapp:v1
        ports:
        - containerPort: 80

Aggiungere un file service.yaml alla directory Deployment con il contenuto seguente per creare un servizio LoadBalancer.

apiVersion: v1
kind: Service
metadata:
  name: aspnetapp-demo-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: aspnetapp-demo

Eseguire il comando seguente per distribuire l'applicazione nel cluster del servizio Azure Kubernetes.
```
kubectl create namespace appconfig-demo
kubectl apply -f ./Deployment -n appconfig-demo
```
Eseguire il comando seguente e ottenere l'indirizzo IP esterno esposto dal servizio LoadBalancer.
```
kubectl get service aspnetapp-demo-service -n appconfig-demo
```
Aprire una finestra del browser e passare all'indirizzo IP ottenuto nel passaggio precedente. La pagina Web è simile alla seguente:

Usare Configurazione app provider Kubernetes

Dopo aver eseguito un'applicazione nel servizio Azure Kubernetes, si distribuirà il provider Kubernetes Configurazione app nel cluster del servizio Azure Kubernetes in esecuzione come controller Kubernetes. Il provider recupera i dati dall'archivio Configurazione app e crea un oggetto ConfigMap, utilizzabile come file JSON montato in un volume di dati.

Configurare l'archivio di configurazione app Azure

Aggiungere i valori chiave seguenti all'archivio Configurazione app e lasciare Etichetta e Tipo di contenuto con i valori predefiniti. Per altre informazioni su come aggiungere valori chiave a un archivio usando il portale di Azure o l'interfaccia della riga di comando, vedere Creare un valore chiave.

Chiave	valore
Impostazioni:FontColor	Verde
Impostazioni:Message	Hello from app Azure Configuration

Configurare il provider Kubernetes Configurazione app

Eseguire il comando seguente per ottenere le credenziali di accesso per il cluster del servizio Azure Kubernetes. Sostituire il valore dei parametri e resource-group con l'istanza name del servizio Azure Kubernetes:
```
az aks get-credentials --name <your-aks-instance-name> --resource-group <your-aks-resource-group>
```

Installare app Azure provider Kubernetes di configurazione nel cluster del servizio Azure Kubernetes usando helm:

helm install azureappconfiguration.kubernetesprovider \
     oci://mcr.microsoft.com/azure-app-configuration/helmchart/kubernetes-provider \
     --namespace azappconfig-system \
     --create-namespace

Aggiungere un file appConfigurationProvider.yaml alla directory Deployment con il contenuto seguente per creare una AzureAppConfigurationProvider risorsa. AzureAppConfigurationProviderè una risorsa personalizzata che definisce i dati da scaricare da un archivio di configurazione app Azure e crea un oggetto ConfigMap.
```
apiVersion: azconfig.io/v1
kind: AzureAppConfigurationProvider
metadata:
  name: appconfigurationprovider-sample
spec:
  endpoint: <your-app-configuration-store-endpoint>
  target:
    configMapName: configmap-created-by-appconfig-provider
    configMapData: 
      type: json
      key: mysettings.json
  auth:
    workloadIdentity:
      managedIdentityClientId: <your-managed-identity-client-id>
```
Sostituire il valore del endpoint campo con l'endpoint dell'archivio di configurazione app Azure. Seguire i passaggi descritti in Usare l'identità del carico di lavoro e aggiornare la auth sezione con l'ID client dell'identità gestita assegnata dall'utente creata.
Nota

AzureAppConfigurationProvider è un oggetto API dichiarativo. Definisce lo stato desiderato di ConfigMap creato dai dati nell'archivio Configurazione app con il comportamento seguente:
- L'oggetto ConfigMap non verrà creato se un oggetto ConfigMap con lo stesso nome esiste già nello stesso spazio dei nomi.
- ConfigMap verrà reimpostato in base ai dati presenti nell'archivio Configurazione app se vengono eliminati o modificati da altri mezzi.
- ConfigMap verrà eliminato se il provider Kubernetes Configurazione app viene disinstallato.

Aggiornare il file deployment.yaml nella directory Deployment per usare ConfigMap configmap-created-by-appconfig-provider come volume di dati montato. È importante assicurarsi che corrisponda all'oggetto volumeMounts.mountPathWORKDIR specificato nel Dockerfile e alla directory di configurazione creata in precedenza.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aspnetapp-demo
  labels:
    app: aspnetapp-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aspnetapp-demo
  template:
    metadata:
      labels:
        app: aspnetapp-demo
    spec:
      containers:
      - name: aspnetapp
        image: myregistry.azurecr.io/aspnetapp:v1
        ports:
        - containerPort: 80
        volumeMounts:
        - name: config-volume
          mountPath: /app/config
      volumes:
      - name: config-volume 
        configMap: 
          name: configmap-created-by-appconfig-provider

Eseguire il comando seguente per distribuire le modifiche. Sostituire lo spazio dei nomi se si usa l'applicazione del servizio Azure Kubernetes esistente.
```
kubectl apply -f ./Deployment -n appconfig-demo
```
Aggiornare il browser. La pagina mostra il contenuto aggiornato.

Risoluzione dei problemi

Se l'applicazione non rileva la raccolta dei dati dall'archivio Configurazione app, eseguire il comando seguente per verificare che ConfigMap sia stato creato correttamente.

kubectl get configmap configmap-created-by-appconfig-provider -n appconfig-demo

Se ConfigMap non viene creato, eseguire il comando seguente per ottenere lo stato di recupero dei dati.

kubectl get AzureAppConfigurationProvider appconfigurationprovider-sample -n appconfig-demo -o yaml

Se il provider Kubernetes di configurazione app Azure ha recuperato correttamente i dati dall'archivio Configurazione app, la phase proprietà nella sezione relativa allo stato dell'output deve essere COMPLETE, come illustrato nell'esempio seguente.

$ kubectl get AzureAppConfigurationProvider appconfigurationprovider-sample -n appconfig-demo -o yaml

apiVersion: azconfig.io/v1
kind: AzureAppConfigurationProvider
  ... ... ...
status:
  lastReconcileTime: "2023-04-06T06:17:06Z"
  lastSyncTime: "2023-04-06T06:17:06Z"
  message: Complete sync settings to ConfigMap or Secret
  phase: COMPLETE

Se la fase non COMPLETEè , i dati non vengono scaricati correttamente dall'archivio Configurazione app. Eseguire il comando seguente per visualizzare i log del provider Kubernetes di configurazione app Azure.

kubectl logs deployment/az-appconfig-k8s-provider -n azappconfig-system

Usare i log per altre operazioni di risoluzione dei problemi. Ad esempio, se vengono visualizzate richieste all'archivio Configurazione app con RESPON edizione Standard 403: 403 Non consentito, potrebbe indicare che il provider Kubernetes Configurazione app non dispone dell'autorizzazione necessaria per accedere all'archivio Configurazione app. Seguire le istruzioni in Usare l'identità del carico di lavoro per assicurarsi che all'identità gestita associata sia assegnata l'autorizzazione appropriata.

Pulire le risorse

Disinstallare il Configurazione app provider Kubernetes dal cluster del servizio Azure Kubernetes se si vuole mantenere il cluster del servizio Azure Kubernetes.

helm uninstall azureappconfiguration.kubernetesprovider --namespace azappconfig-system

Se non si vuole continuare a usare le risorse create in questo articolo, eliminare il gruppo di risorse creato qui per evitare addebiti.

Importante

L'eliminazione di un gruppo di risorse è irreversibile. Il gruppo di risorse e tutte le risorse in esso contenute vengono eliminati in modo permanente. Assicurarsi di non eliminare accidentalmente il gruppo di risorse o le risorse sbagliate. Se le risorse per questo articolo sono state create in un gruppo di risorse che contiene altre risorse che si vogliono mantenere, eliminare ogni risorsa singolarmente dal rispettivo riquadro anziché eliminare il gruppo di risorse.

Accedere al portale di Azure e selezionare Gruppi di risorse.
Nella casella Filtra per nome immettere il nome del gruppo di risorse.
Nell'elenco dei risultati selezionare il nome del gruppo di risorse per visualizzare una panoramica.
Selezionare Elimina gruppo di risorse.
Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Immettere il nome del gruppo di risorse per confermare e selezionare Elimina.

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Nota

Se si usa l'interfaccia della riga di comando per sviluppatori di Azure per configurare le risorse, è possibile eseguire il azd down comando per eliminare tutte le risorse create dal azure-appconfig-aks modello.

Passaggi successivi

Questa guida introduttiva spiega come:

Creazione di un'applicazione in esecuzione in servizio Azure Kubernetes (servizio Azure Kubernetes).
Connessione il cluster del servizio Azure Kubernetes nell'archivio Configurazione app usando il provider Kubernetes Configurazione app.
Creazione di un oggetto ConfigMap con i dati dall'archivio Configurazione app.
L'applicazione è stata eseguita con la configurazione dall'archivio Configurazione app senza modificare il codice dell'applicazione.

Per informazioni su come aggiornare i carichi di lavoro del servizio Azure Kubernetes per aggiornare dinamicamente la configurazione, continuare con l'esercitazione successiva.

Usare la configurazione dinamica in servizio Azure Kubernetes

Per altre informazioni sul provider Kubernetes di configurazione app Azure, vedere app Azure Informazioni di riferimento sul provider Kubernetes di configurazione.

Share via