Schnellstart: Bereitstellen eines Azure Linux mit OS Guard (Vorschau) Azure Kubernetes Service (AKS) Cluster mithilfe des Azure CLI

In dieser Schnellstartanleitung erfahren Sie, wie Sie:

Voraussetzungen

• Wenn Sie nicht über ein Azure-Konto verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.

• Verwenden Sie die Bash-Umgebung in Azure Cloud Shell. Weitere Informationen finden Sie unter Azure Cloud Shell-Schnellstart: Bash.

  

• Wenn Sie CLI-Referenzbefehle lieber lokal ausführen möchten, installieren Sie den Azure CLI. Wenn Sie mit Windows oder macOS arbeiten, sollten Sie die Azure CLI in einem Docker-Container ausführen. Weitere Informationen finden Sie unter How to run the Azure CLI in a Docker container.

  • Wenn Sie eine lokale Installation verwenden, melden Sie sich mit dem Befehl az login beim Azure CLI an. Führen Sie die in Ihrem Terminal angezeigten Schritte aus, um den Authentifizierungsprozess abzuschließen. Informationen zu anderen Anmeldeoptionen finden Sie unter Anmelden mit der Azure CLI.
  • Wenn Sie dazu aufgefordert werden, installieren Sie die Azure CLI-Erweiterung bei der ersten Verwendung. Weitere Informationen zu Erweiterungen finden Sie unter Verwenden von Erweiterungen mit der Azure CLI.
  • Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu finden. Führen Sie az upgrade aus, um auf die neueste Version zu aktualisieren.

Azure Linux mit Hinweisen und Einschränkungen zu OS Guard

Bevor Sie beginnen, lesen Sie die folgenden Überlegungen und Einschränkungen für Azure Linux mit OS Guard (Vorschau):

• Kubernetes Version 1.32.0 oder höher ist für Azure Linux mit OS Guard erforderlich.
• Alle Azure Linux-Images mit OS Guard haben den Federal Information Process Standard (FIPS) und Trusted Launch aktiviert.
• Azure CLI und ARM-Vorlagen sind die einzigen unterstützten Bereitstellungsmethoden für Azure Linux mit OS Guard auf AKS in Preview. PowerShell und Terraform werden nicht unterstützt.
• Arm64-Images werden mit Azure Linux und OS Guard auf AKS in der Vorschauphase nicht unterstützt.
• NodeImage und None sind die einzigen unterstützten Betriebssystem-(OS-)Upgradekanäle für Azure Linux mit OS Guard auf AKS. Unmanaged und SecurityPatch sind aufgrund des unveränderlichen /usr-Verzeichnisses nicht mit Azure Linux mit OS Guard kompatibel.
• Artefaktstreaming wird nicht unterstützt.
• Pod Sandboxing wird nicht unterstützt.
• Vertrauliche virtuelle Computer (CVMs) werden nicht unterstützt.
• Virtuelle Computer der Generation 1 (VMs) werden nicht unterstützt.

Installieren Sie die aks-preview Azure CLI-Erweiterung

Installieren Sie die „aks-preview“-Erweiterung mithilfe des Befehls „az extension add“.

az extension add --name aks-preview

Aktualisieren Sie die aks-preview Erweiterung mithilfe des az extension update Befehls auf die neueste Version.

az extension update --name aks-preview

Registriere die AzureLinuxOSGuardPreview-Feature-Flag

1. Registrieren Sie das Featureflag AzureLinuxOSGuardPreview mithilfe des Befehls az feature register.

   az feature register --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"
   

   Es dauert einige Minuten, bis der Status Registered (Registriert) angezeigt wird.

2. Überprüfen Sie den Registrierungsstatus mithilfe des Befehls az feature show.

   az feature show --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"
   

3. Wenn der Zustand Registered (Registriert) lautet, aktualisieren Sie die Registrierung des Ressourcenanbieters Microsoft.ContainerService mithilfe des Befehls az provider register.

   az provider register --namespace "Microsoft.ContainerService"
   

Festlegen von Umgebungsvariablen

Legen Sie die folgenden Umgebungsvariablen fest, um eindeutige Ressourcennamen für jede Bereitstellung zu erstellen. Ersetzen Sie <your-resource-group-name>, <your-region> und <your-cluster-name> durch Ihre eigenen Werte. Sie können optional den openssl rand -hex 3 Befehl verwenden, um eine zufällige Zeichenfolge zu generieren, die an Ihre Ressourcengruppen- und Clusternamen angefügt werden soll (z. B export RESOURCE_GROUP="myResourceGroup$RANDOM_ID". ).

# Create random string
export RANDOM_ID="$(openssl rand -hex 3)"

# Set environment variables
export RESOURCE_GROUP="<your-resource-group-name>"
export REGION="<your-region>"
export CLUSTER_NAME="<your-cluster-name>"

Erstellen einer Ressourcengruppe

Eine Azure-Ressourcengruppe ist eine logische Gruppe, in der Azure-Ressourcen bereitgestellt und verwaltet werden. Beim Erstellen einer Ressourcengruppe in Azure müssen Sie einen Speicherort angeben. Dieser Speicherort ist der Speicherort Ihrer Ressourcengruppenmetadaten und der Speicherort, an dem Ihre Ressourcen in Azure ausgeführt werden, wenn Sie beim Erstellen einer Ressource keine andere Region angeben.

Erstellen Sie mit dem Befehl az group create eine Ressourcengruppe.

az group create --name $RESOURCE_GROUP --location $REGION

Beispielausgabe:

{
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$RESOURCE_GROUPxxxxxx",
  "location": "$REGION",
  "managedBy": null,
  "name": "$RESOURCE_GROUPxxxxxx",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Erstellen eines Azure Linux mit OS Guard-Cluster

Erstellen Sie einen AKS-Cluster unter Verwendung des az aks create-Befehls und des --os-sku-Parameters, um den AKS-Cluster mit einem Azure-Linux-Image mit OS Guard bereitzustellen.

az aks create --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --os-sku AzureLinuxOSGuard --node-osdisk-type Managed --enable-fips-image --enable-secure-boot --enable-vtpm 

Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.

Herstellen einer Verbindung mit dem Cluster

Verwenden Sie zum Verwalten eines Kubernetes-Clusters den Kubernetes-Befehlszeilenclient kubectl. kubectl ist bereits installiert, wenn Sie Azure Cloud Shell verwenden. Um kubectl lokal zu installieren, verwenden Sie den Befehl az aks install-cli.

1. Mit dem Befehl kubectl können Sie az aks get-credentials für die Verbindungsherstellung mit Ihrem Kubernetes-Cluster konfigurieren. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

   az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME
   

2. Überprüfen Sie die Verbindung mit dem Cluster mithilfe des Befehls kubectl get. Dieser Befehl gibt eine Liste der Clusterknoten zurück.

   kubectl get nodes
   

Stellen Sie die Anwendung bereit

Zum Bereitstellen der Anwendung verwenden Sie eine Manifestdatei, um alle Objekte zu erstellen, die zum Ausführen der AKS Store-Anwendung erforderlich sind. Eine Kubernetes-Manifestdatei definiert den gewünschten Zustand (Desired State) eines Clusters, also beispielsweise, welche Containerimages ausgeführt werden sollen. Das Manifest umfasst die folgenden Kubernetes-Bereitstellungen und -Dienste:

• Store Front: Webanwendung für Kund*innen zum Anzeigen von Produkten und Aufgeben von Bestellungen
• Produktservice: Zeigt Produktinformationen an.
• Bestellservice: Bestellungen aufgeben.
• Rabbit MQ: Nachrichtenwarteschlange für eine Auftragswarteschlange.

1. Erstellen Sie eine Datei namens aks-store-quickstart.yaml, und fügen Sie das folgende Manifest ein:

   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     name: rabbitmq
   spec:
     serviceName: rabbitmq
     replicas: 1
     selector:
       matchLabels:
         app: rabbitmq
     template:
       metadata:
         labels:
           app: rabbitmq
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: rabbitmq
           image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
           ports:
           - containerPort: 5672
             name: rabbitmq-amqp
           - containerPort: 15672
             name: rabbitmq-http
           env:
           - name: RABBITMQ_DEFAULT_USER
             value: "username"
           - name: RABBITMQ_DEFAULT_PASS
             value: "password"
           resources:
             requests:
               cpu: 10m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           volumeMounts:
           - name: rabbitmq-enabled-plugins
             mountPath: /etc/rabbitmq/enabled_plugins
             subPath: enabled_plugins
         volumes:
         - name: rabbitmq-enabled-plugins
           configMap:
             name: rabbitmq-enabled-plugins
             items:
             - key: rabbitmq_enabled_plugins
               path: enabled_plugins
   ---
   apiVersion: v1
   data:
     rabbitmq_enabled_plugins: |
       [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
   kind: ConfigMap
   metadata:
     name: rabbitmq-enabled-plugins            
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: rabbitmq
   spec:
     selector:
       app: rabbitmq
     ports:
       - name: rabbitmq-amqp
         port: 5672
         targetPort: 5672
       - name: rabbitmq-http
         port: 15672
         targetPort: 15672
     type: ClusterIP
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: order-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: order-service
     template:
       metadata:
         labels:
           app: order-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: order-service
           image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
           ports:
           - containerPort: 3000
           env:
           - name: ORDER_QUEUE_HOSTNAME
             value: "rabbitmq"
           - name: ORDER_QUEUE_PORT
             value: "5672"
           - name: ORDER_QUEUE_USERNAME
             value: "username"
           - name: ORDER_QUEUE_PASSWORD
             value: "password"
           - name: ORDER_QUEUE_NAME
             value: "orders"
           - name: FASTIFY_ADDRESS
             value: "0.0.0.0"
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi
           startupProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 20
             periodSeconds: 10
           readinessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
         initContainers:
         - name: wait-for-rabbitmq
           image: busybox
           command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi    
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: order-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3000
       targetPort: 3000
     selector:
       app: order-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: product-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: product-service
     template:
       metadata:
         labels:
           app: product-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: product-service
           image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
           ports:
           - containerPort: 3002
           env: 
           - name: AI_SERVICE_URL
             value: "http://ai-service:5001/"
           resources:
             requests:
               cpu: 1m
               memory: 1Mi
             limits:
               cpu: 2m
               memory: 20Mi
           readinessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: product-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3002
       targetPort: 3002
     selector:
       app: product-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store-front
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: store-front
     template:
       metadata:
         labels:
           app: store-front
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: store-front
           image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
           ports:
           - containerPort: 8080
             name: store-front
           env: 
           - name: VUE_APP_ORDER_SERVICE_URL
             value: "http://order-service:3000/"
           - name: VUE_APP_PRODUCT_SERVICE_URL
             value: "http://product-service:3002/"
           resources:
             requests:
               cpu: 1m
               memory: 200Mi
             limits:
               cpu: 1000m
               memory: 512Mi
           startupProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 5
             periodSeconds: 5
           readinessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 3
           livenessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: store-front
   spec:
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: store-front
     type: LoadBalancer
   

   Wenn Sie die YAML-Datei lokal erstellen und speichern, können Sie die Manifestdatei in Ihr Standardverzeichnis in CloudShell hochladen, indem Sie die Schaltfläche " Dateien hochladen/herunterladen " auswählen und die Datei aus Ihrem lokalen Dateisystem auswählen.

2. Stellen Sie die Anwendung über den Befehl „kubectl apply“ bereit, und geben Sie den Namen Ihres YAML-Manifests an.

   kubectl apply -f aks-store-quickstart.yaml
   

Testen der App

Sie können überprüfen, ob die Anwendung ausgeführt wird, indem Sie die öffentliche IP-Adresse oder die Anwendungs-URL aufrufen.

Rufen Sie die Anwendungs-URL mit den folgenden Befehlen ab:

runtime="5 minutes"
endtime=$(date -ud "$runtime" +%s)
while [[ $(date -u +%s) -le $endtime ]]
do
   STATUS=$(kubectl get pods -l app=store-front -o 'jsonpath={..status.conditions[?(@.type=="Ready")].status}')
   echo $STATUS
   if [ "$STATUS" == 'True' ]
   then
      export IP_ADDRESS=$(kubectl get service store-front --output 'jsonpath={..status.loadBalancer.ingress[0].ip}')
      echo "Service IP Address: $IP_ADDRESS"
      break
   else
      sleep 10
   fi
done

curl $IP_ADDRESS

Ergebnisse:

<!doctype html>
<html lang="">
   <head>
      <meta charset="utf-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width,initial-scale=1">
      <link rel="icon" href="/favicon.ico">
      <title>store-front</title>
      <script defer="defer" src="/js/chunk-vendors.df69ae47.js"></script>
      <script defer="defer" src="/js/app.7e8cfbb2.js"></script>
      <link href="/css/app.a5dc49f6.css" rel="stylesheet">
   </head>
   <body>
      <div id="app"></div>
   </body>
</html>

echo "You can now visit your web server at $IP_ADDRESS"

Löschen des Clusters

Wenn Sie sie nicht mehr benötigen, können Sie unnötige Ressourcen bereinigen, um Azure-Gebühren zu vermeiden.

Löschen Sie die Azure Ressourcengruppe und alle zugehörigen Ressourcen mithilfe des Befehls az group delete.

az group delete --name $RESOURCE_GROUP --yes --no-wait

Verwandte Inhalte

In dieser Schnellstartanleitung haben Sie ein Azure Linux mit OS Guard-Cluster bereitgestellt. Weitere Informationen zu Azure Linux mit OS Guard finden Sie in den folgenden Ressourcen:

• lernprogrammreihe Azure Linux OS Guard: Teil 1
• Übersicht über Azure Linux OS Guard für AKS