Snabbstart: Använda Azure App Configuration i Azure Kubernetes Service

Artikel
04/30/2024

I Kubernetes konfigurerar du poddar för att använda konfiguration från Config Kartor. Det gör att du kan frikoppla konfigurationen från dina containeravbildningar, vilket gör dina program lätt bärbara. Kubernetes-providern för Azure App Configuration kan konstruera konfiguration Kartor och hemligheter från dina nyckelvärden och Key Vault-referenser i Azure App Configuration. Det gör att du kan dra nytta av Azure App Configuration för centraliserad lagring och hantering av konfigurationen utan några ändringar i programkoden.

En ConfigMap kan användas som miljövariabler eller en monterad fil. I den här snabbstarten införlivar du Azure App Configuration Kubernetes-providern i en Azure Kubernetes Service-arbetsbelastning där du kör en enkel ASP.NET Core-app som förbrukar konfiguration från en JSON-fil.

Dricks

Se alternativ för arbetsbelastningar som finns i Kubernetes för åtkomst till Azure App Configuration.

Kommentar

Den här snabbstarten beskriver hur du konfigurerar Kubernetes-providern för Azure App Configuration. Du kan också använda följande Azure Developer CLI-kommandon med mallen azure-appconfig-aks för att etablera Azure-resurser och distribuera exempelprogrammet som används av den här snabbstarten. Mer information om den här mallen finns på lagringsplatsen azure-appconfig-aks på GitHub.

azd init -t azure-appconfig-aks
azd up

Förutsättningar

Ett appkonfigurationsarkiv. Skapa en butik.
Ett Azure Container Registry. Skapa ett register.
Ett AKS-kluster (Azure Kubernetes Service) som har behörighet att hämta avbildningar från Azure Container Registry. Skapa ett AKS-kluster.
.NET SDK 6.0 eller senare
Azure CLI
Docker Desktop
Rodret
kubectl

Skapa ett program som körs i AKS

I det här avsnittet skapar du ett enkelt ASP.NET Core-webbprogram som körs i Azure Kubernetes Service (AKS). Programmet läser konfigurationen från en lokal JSON-fil. I nästa avsnitt gör du det möjligt för den att använda konfiguration från Azure App Configuration utan att ändra programkoden. Om du redan har ett AKS-program som läser konfigurationen från en fil hoppar du över det här avsnittet och går till Använd App Configuration Kubernetes-provider. Du behöver bara se till att konfigurationsfilen som genereras av providern matchar den filsökväg som används av ditt program.

Skapa ett program

Använd .NET-kommandoradsgränssnittet (CLI) och kör följande kommando för att skapa ett nytt ASP.NET Core-webbappsprojekt i en ny MyWebApp-katalog :
```
dotnet new webapp --output MyWebApp --framework net6.0
```

Öppna Index.cshtml i katalogen Pages och uppdatera innehållet med följande kod.

@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>

Skapa en konfigurationskatalog i projektets rot och lägg till en mysettings.json fil i den med följande innehåll.
```
{
  "Settings": {
    "FontColor": "Black",
    "Message": "Message from the local configuration"
  }
}
```

Öppna program.cs och lägg till JSON-filen i konfigurationskällan genom att anropa AddJsonFile metoden.

// 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
// ... ...

Använd programmet med en container

Kör kommandot dotnet publish för att skapa appen i versionsläge och skapa tillgångarna i den publicerade katalogen.
```
dotnet publish -c Release -o published
```
Skapa en fil med namnet Dockerfile i roten av projektkatalogen, öppna den i en textredigerare och ange följande innehåll. En Dockerfile är en textfil som inte har något tillägg och som används för att skapa en containeravbildning.
```
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
WORKDIR /app
COPY published/ ./
ENTRYPOINT ["dotnet", "MyWebApp.dll"]
```
Skapa en containeravbildning med namnet aspnetapp genom att köra följande kommando.
```
docker build --tag aspnetapp .
```

Skicka avbildningen till Azure Container Registry

Kör kommandot az acr login för att logga in i containerregistret. Följande exempel loggar in i ett register med namnet myregistry. Ersätt registernamnet med ditt.
```
az acr login --name myregistry
```
Kommandot returnerar Login Succeeded när inloggningen har slutförts.
Använd docker-taggen för att skapa en tagg myregistry.azurecr.io/aspnetapp:v1 för avbildningens aspnetapp.
```
docker tag aspnetapp myregistry.azurecr.io/aspnetapp:v1
```
Dricks

Om du vill granska listan över dina befintliga Docker-avbildningar och taggar kör du docker image ls. I det här scenariot bör du se minst två bilder: aspnetapp och myregistry.azurecr.io/aspnetapp.
Använd docker-push för att ladda upp avbildningen till containerregistret. Följande kommando skickar till exempel avbildningen till en lagringsplats med namnet aspnetapp med tagg v1 under registrets myregistry.
```
docker push myregistry.azurecr.io/aspnetapp:v1
```

Distribuera programmet

Skapa en distributionskatalog i rotkatalogen för projektet.

Lägg till en deployment.yaml-fil i distributionskatalogen med följande innehåll för att skapa en distribution. Ersätt värdet för med den bild template.spec.containers.image som du skapade i föregående steg.

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

Lägg till en service.yaml-fil i distributionskatalogen med följande innehåll för att skapa en LoadBalancer-tjänst.

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

Kör följande kommando för att distribuera programmet till AKS-klustret.

kubectl create namespace appconfig-demo
kubectl apply -f ./Deployment -n appconfig-demo

Kör följande kommando och hämta den externa IP-adressen som exponeras av LoadBalancer-tjänsten.
```
kubectl get service aspnetapp-demo-service -n appconfig-demo
```
Öppna ett webbläsarfönster och navigera till DEN IP-adress som erhölls i föregående steg. Webbsidan ser ut så här:

Använda Kubernetes-provider för appkonfiguration

Nu när du har ett program som körs i AKS distribuerar du Kubernetes-providern för appkonfiguration till aks-klustret som körs som en Kubernetes-kontrollant. Providern hämtar data från appkonfigurationsarkivet och skapar en ConfigMap som kan användas som en JSON-fil monterad i en datavolym.

Konfigurera Azure App Configuration Store

Lägg till följande nyckelvärden i App Configuration Store och lämna Etikett och Innehållstyp med sina standardvärden. Mer information om hur du lägger till nyckelvärden i ett arkiv med hjälp av Azure-portalen eller CLI finns i Skapa ett nyckelvärde.

Tangent	Värde
Inställningar:FontColor	Grön
Inställningar:Meddelande	Hej från Azure App Configuration

Konfigurera Kubernetes-providern för appkonfiguration

Kör följande kommando för att hämta autentiseringsuppgifter för ditt AKS-kluster. Ersätt värdet för parametrarna name och resource-group med din AKS-instans:
```
az aks get-credentials --name <your-aks-instance-name> --resource-group <your-aks-resource-group>
```

Installera Azure App Configuration Kubernetes-providern i ditt AKS-kluster med hjälp av helm:

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

Lägg till en appConfigurationProvider.yaml-fil i distributionskatalogenmed följande innehåll för att skapa en AzureAppConfigurationProvider resurs. AzureAppConfigurationProvider är en anpassad resurs som definierar vilka data som ska laddas ned från ett Azure App Configuration Store och skapar en 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>
```
Ersätt värdet för endpoint fältet med slutpunkten för ditt Azure App Configuration Store. Följ stegen i använda arbetsbelastningsidentitet och uppdatera auth avsnittet med klient-ID för den användartilldelade hanterade identiteten som du skapade.
Kommentar

AzureAppConfigurationProvider är ett deklarativt API-objekt. Den definierar det önskade tillståndet för ConfigMap som skapats från data i appkonfigurationsarkivet med följande beteende:
- Det går inte att skapa ConfigMap om det redan finns en ConfigMap med samma namn i samma namnområde.
- ConfigMap återställs baserat på aktuella data i appkonfigurationsarkivet om den tas bort eller ändras på något annat sätt.
- ConfigMap tas bort om Kubernetes-providern för appkonfiguration avinstalleras.

Uppdatera filen deployment.yaml i distributionskatalogen så att ConfigMap configmap-created-by-appconfig-provider används som en monterad datavolym. Det är viktigt att se till att matchar angivna volumeMounts.mountPathWORKDIR i din Dockerfile och konfigurationskatalogensom skapades tidigare.

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

Kör följande kommando för att distribuera ändringarna. Ersätt namnområdet om du använder ditt befintliga AKS-program.
```
kubectl apply -f ./Deployment -n appconfig-demo
```
Uppdatera webbläsaren. Sidan visar uppdaterat innehåll.

Felsökning

Om du inte ser att programmet hämtar data från appkonfigurationsarkivet kör du följande kommando för att verifiera att ConfigMap har skapats korrekt.

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

Om ConfigMap inte har skapats kör du följande kommando för att hämta datahämtningsstatusen.

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

Om Kubernetes-providern för Azure App Configuration hämtade data från appkonfigurationsarkivet phase ska egenskapen under statusavsnittet i utdata vara COMPLETE, enligt följande exempel.

$ 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

Om fasen inte COMPLETEär hämtas inte data från appkonfigurationsarkivet korrekt. Kör följande kommando för att visa loggarna för Kubernetes-providern för Azure App Configuration.

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

Använd loggarna för ytterligare felsökning. Om du till exempel ser att begäranden till appkonfigurationsarkivet besvaras med SVAR 403: 403 Förbjudet kan det tyda på att Kubernetes-providern för appkonfiguration inte har den behörighet som krävs för att få åtkomst till appkonfigurationsarkivet. Följ anvisningarna i använda arbetsbelastningsidentitet för att säkerställa att associerad hanterad identitet tilldelas rätt behörighet.

Rensa resurser

Avinstallera Kubernetes-providern för appkonfiguration från AKS-klustret om du vill behålla AKS-klustret.

helm uninstall azureappconfiguration.kubernetesprovider --namespace azappconfig-system

Om du inte vill fortsätta använda resurserna som skapas i den här artikeln tar du bort resursgruppen som du skapade här för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. Resursgruppen och alla resurser i den tas bort permanent. Se till att du inte oavsiktligt tar bort fel resursgrupp eller resurser. Om du har skapat resurserna för den här artikeln i en resursgrupp som innehåller andra resurser som du vill behålla tar du bort varje resurs individuellt från respektive fönster i stället för att ta bort resursgruppen.

Logga in på Azure-portalen och välj Resursgrupper.
I rutan Filtrera efter namn anger du namnet på resursgruppen.
I resultatlistan väljer du resursgruppens namn för att se en översikt.
Välj Ta bort resursgrupp.
Du blir ombedd att bekräfta borttagningen av resursgruppen. Ange namnet på resursgruppen för att bekräfta och välj Ta bort.

Efter en liten stund tas resursgruppen och alla dess resurser bort.

Kommentar

Om du använder Azure Developer CLI för att konfigurera resurserna kan du köra azd down kommandot för att ta bort alla resurser som skapats av mallen azure-appconfig-aks .

Nästa steg

I den här snabbstarten kommer du att göra följande:

Skapade ett program som körs i Azure Kubernetes Service (AKS).
Anslut aks-klustret till appkonfigurationsarkivet med hjälp av Kubernetes-providern för appkonfiguration.
Skapade en ConfigMap med data från appkonfigurationsarkivet.
Körde programmet med konfiguration från appkonfigurationsarkivet utan att ändra programkoden.

Om du vill lära dig hur du uppdaterar dina AKS-arbetsbelastningar för att dynamiskt uppdatera konfigurationen fortsätter du till nästa självstudie.

Använda dynamisk konfiguration i Azure Kubernetes Service

Mer information om Kubernetes-providern för Azure App Configuration finns i Referens för Azure App Configuration Kubernetes Provider.

Share via