Quickstart: Een Azure Linux implementeren met OS Guard (preview) AKS-cluster met behulp van de Azure CLI

Ga aan de slag met Azure Linux met OS Guard met behulp van de Azure CLI om een Azure Linux te implementeren met OS Guard Container Host voor AKS-cluster. Nadat u de vereisten hebt geïnstalleerd, installeert u de Azure CLI-extensie aks-preview, registreert u de functievlag AzureLinuxOSGuardPreview, maakt u een resourcegroep, maakt u een AKS-cluster, maakt u verbinding met het cluster en voert u een voorbeeldtoepassing met meerdere containers uit in het cluster.

Overwegingen en beperkingen

Bekijk voordat u begint de volgende overwegingen en beperkingen voor Azure Linux met OS Guard (preview):

• Kubernetes versie 1.32.0 of hoger is vereist voor Azure Linux met OS Guard.
• Alle Azure Linux-installatiekopieën met OS Guard hebben FIPS (Federal Information Process Standard) en Trusted Launch ingeschakeld.
• Azure CLI- en ARM-sjablonen zijn de enige ondersteunde implementatiemethoden voor Azure Linux met OS Guard in AKS in preview. PowerShell en Terraform worden niet ondersteund.
• Arm64-images worden niet ondersteund met Azure Linux met OS Guard in AKS in preview.
• NodeImage en None zijn de enige ondersteunde kanalen voor het upgraden van besturingssystemen voor Azure Linux met OS Guard op AKS. Unmanaged en SecurityPatch zijn niet compatibel met Azure Linux met OS Guard vanwege de onveranderbare /usr-map.
• Artefactstreaming wordt niet ondersteund.
• Pod Sandboxing wordt niet ondersteund.
• Confidential Virtual Machines (CVM's) worden niet ondersteund.
• Virtuele machines (VM's) van Gen 1 worden niet ondersteund.

Vereiste voorwaarden

• Als u geen Azure-account hebt, maak dan een gratis account aan voordat u begint.

• Gebruik de Bash-omgeving in Azure Cloud Shell. Zie Azure Cloud Shell-snelstart: Bash voor meer informatie.

  

• Als je de voorkeur geeft aan het lokaal uitvoeren van CLI-referentiecommando's, installeer dan de Azure CLI. Als je op Windows of macOS werkt, overweeg dan om Azure CLI in een Docker-container uit te voeren. Voor meer informatie, zie Hoe u de Azure CLI in een Docker-container kunt uitvoeren.

  • Als u een lokale installatie gebruikt, meldt u zich aan bij Azure CLI met de opdracht az login. Om het authenticatieproces te voltooien, volgt u de stappen die op uw terminal worden weergegeven. Raadpleeg Aanmelden bij Azure CLI voor aanvullende aanmeldingsopties.
  • Wanneer u daarom wordt gevraagd, installeer de Azure CLI-extensie bij het eerste gebruik. Raadpleeg Extensies gebruiken met Azure CLI voor meer informatie over extensies.
  • Voer az version uit om de versie en afhankelijke bibliotheken te vinden die zijn geïnstalleerd. Voer az upgrade uit om naar de nieuwste versie te upgraden.

De Azure CLI-extensie aks-preview installeren

Voer de volgende opdracht uit om de aks-preview-extensie te installeren:

az extension add --name aks-preview

Voer de volgende opdracht uit om bij te werken naar de nieuwste versie van de extensie die is uitgebracht:

az extension update --name aks-preview

De functievlag AzureLinuxOSGuardPreview registreren

Registreer de AzureLinuxOSGuardPreview functievlag met behulp van de opdracht az feature register , zoals wordt weergegeven in het volgende voorbeeld:

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

Het duurt enkele minuten voordat de status Geregistreerd wordt weergegeven. Controleer de registratiestatus met behulp van de opdracht az feature show :

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

Wanneer de status Geregistreerd is, vernieuwt u de registratie van de Resourceprovider Microsoft.ContainerService met behulp van de opdracht az provider register:

az provider register --namespace "Microsoft.ContainerService"

Een brongroep maken

Een Azure-resourcegroep is een logische groep waarin Azure-resources worden geïmplementeerd en beheerd. Wanneer u een resourcegroep maakt, moet u een locatie opgeven. Deze locatie is:

• De opslaglocatie van de metagegevens van de resourcegroep.
• Waar uw resources worden uitgevoerd in Azure als u geen andere regio opgeeft bij het maken van een resource.

Maak een resourcegroep met behulp van de az group create opdracht.

export RANDOM_ID="$(openssl rand -hex 3)"
export MY_RESOURCE_GROUP_NAME="myAzureLinuxOSGuardResourceGroup$RANDOM_ID"
export REGION="westeurope"

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

Resultaten:

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

Een Azure Linux maken met OS Guard-cluster

Maak een AKS-cluster met behulp van de az aks create opdracht met de --os-sku parameter om het AKS-cluster in te richten met een Azure Linux met OS Guard-image.

export MY_AZ_CLUSTER_NAME="myAzureLinuxOSGuardCluster$RANDOM_ID"

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

Na enkele minuten is de opdracht voltooid en retourneert deze informatie over het cluster in JSON-indeling.

Verbinding maken met het cluster

Als u een Kubernetes-cluster wilt beheren, gebruikt u de Kubernetes-opdrachtregelclient. kubectl kubectl is al geïnstalleerd als u Azure Cloud Shell gebruikt. Als u lokaal wilt installeren kubectl , gebruikt u de az aks install-cli opdracht.

1. Configureer kubectl om verbinding te maken met uw Kubernetes-cluster met behulp van het az aks get-credentials commando. Bij deze opdracht worden inloggegevens gedownload en wordt de Kubernetes CLI geconfigureerd om deze te gebruiken.

   az aks get-credentials --resource-group $MY_RESOURCE_GROUP_NAME --name $MY_AZ_CLUSTER_NAME
   

2. Controleer de verbinding met uw cluster met behulp van de kubectl get opdracht. Met deze opdracht wordt een lijst met de clusterknooppunten geretourneerd.

   kubectl get nodes
   

De toepassing implementeren

Als u de toepassing wilt implementeren, gebruikt u een manifestbestand om alle objecten te maken die nodig zijn om de AKS Store-toepassing uit te voeren. Een Kubernetes-manifestbestand definieert de gewenste status van een cluster, zoals welke containerinstallatiekopieën moeten worden uitgevoerd. Het manifest bevat de volgende Kubernetes-implementaties en -services:

• Webwinkel: Webtoepassing voor klanten om producten te bekijken en bestellingen te plaatsen.
• Productservice: toont productgegevens.
• Orderservice: Orders plaatsen.
• Rabbit MQ: Berichtensysteem voor een bestelwachtrij.

1. Maak een bestand met de naam aks-store-quickstart.yaml en kopieer dit in het volgende manifest:

   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
   

   Als u het YAML-bestand lokaal maakt en opslaat, kunt u het manifestbestand uploaden naar uw standaardmap in CloudShell door de knop Bestanden uploaden/downloaden te selecteren en het bestand in uw lokale bestandssysteem te selecteren.

2. Implementeer de toepassing met behulp van de kubectl apply opdracht en geef de naam van uw YAML-manifest op.

   kubectl apply -f aks-store-quickstart.yaml
   

De toepassing testen

U kunt controleren of de toepassing wordt uitgevoerd door naar het openbare IP-adres of de toepassings-URL te gaan.

Haal de toepassings-URL op met behulp van de volgende opdrachten:

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

Resultaten:

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

Het cluster verwijderen

Als u ze niet meer nodig hebt, kunt u overbodige resources opschonen om Azure-kosten te voorkomen. U kunt de resourcegroep, containerservice en alle gerelateerde resources verwijderen met behulp van de az group delete opdracht.

Volgende stappen

In deze quickstart hebt u een Azure Linux met OS Guard-cluster geïmplementeerd. Als u meer wilt weten over Azure Linux met OS Guard en een volledig voorbeeld van clusterimplementatie en -beheer doorloopt, gaat u verder met azure Linux met OS Guard.