Guida introduttiva: distribuire un cluster di Servizio Azure Kubernetes (AKS) con Azure Container Linux (ACL) usando l'interfaccia della riga di comando di Azure (interfaccia della riga di comando di Azure)

In questa guida introduttiva si userà il interfaccia della riga di comando di Azure per creare un cluster Servizio Azure Kubernetes (AKS) che esegue Azure Contenitore Linux (ACL) come sistema operativo del nodo. Dopo aver distribuito il cluster, connettersi usando kubectl e verificare che i nodi ACL siano in esecuzione come previsto.

Considerazioni e limitazioni

Prima di iniziare, esamina le seguenti considerazioni e limitazioni per ACL:

Prerequisiti

Annotazioni

È possibile usare Azure Cloud Shell o un'installazione locale del interfaccia della riga di comando di Azure per eseguire i comandi in questa guida introduttiva.

Registrare il provider di risorse Microsoft.ContainerService

Potrebbe essere necessario registrare i provider di risorse nella sottoscrizione di Azure. Controllare lo stato della registrazione usando il az provider show comando .

az provider show --namespace Microsoft.ContainerService --query registrationState

Se necessario, registrare il provider di risorse usando il az provider register comando .

az provider register --namespace Microsoft.ContainerService

Creare un gruppo di risorse

Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite. Quando si crea un gruppo di risorse, è necessario specificare una posizione. Questa posizione è:

  • Posizione di archiviazione dei metadati del gruppo di risorse.
  • È dove vengono eseguite le risorse in Azure se non si specifica un'area differente durante la creazione di una risorsa.

Creare un gruppo di risorse usando il comando az group create. L'esempio seguente imposta le variabili di ambiente per il nome del gruppo di risorse, l'area e il nome del cluster del servizio Azure Kubernetes, quindi crea un gruppo di risorse nella posizione specificata. È possibile sostituire i valori delle variabili di ambiente con nomi e aree preferiti.

export MY_RESOURCE_GROUP_NAME="myACLResourceGroup"
export REGION="westus"
export MY_AKS_CLUSTER_NAME="myACLCluster"

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

Output di esempio:

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

Creare un cluster ACL

Creare un cluster AKS usando il comando az aks create con il parametro --os-sku AzureContainerLinux per eseguire il provisioning del cluster AKS con un'immagine ACL.

az aks create \
  --resource-group $MY_RESOURCE_GROUP_NAME \
  --name $MY_AKS_CLUSTER_NAME \
  --os-sku AzureContainerLinux \
  --node-count 3 \
  --generate-ssh-keys

Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

Connettersi al cluster

Per gestire un cluster Kubernetes, usare il client da riga di comando Kubernetes kubectl. kubectl è già installato se si usa Azure Cloud Shell. Per installare kubectl in locale, usare il comando az aks install-cli.

  1. Configurare kubectl per connettersi al cluster Kubernetes usando il comando az aks get-credentials. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarle.

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

  2. Verificare la connessione al cluster usando il comando kubectl get. Questo comando restituisce un elenco dei nodi del cluster.

    kubectl get nodes

Distribuire l'applicazione

Per distribuire l'applicazione, utilizzare un file manifesto per creare tutti gli oggetti necessari per eseguire l'applicazione AKS Store. Un file manifesto Kubernetes definisce lo stato desiderato di un cluster, ad esempio le immagini del contenitore da eseguire. Il manifesto include le distribuzioni e i servizi Kubernetes seguenti:

  • Vetrina di vendita: applicazione Web che consente ai clienti di visualizzare i prodotti ed effettuare ordini.
  • Servizio prodotto: mostra le informazioni sul prodotto.
  • Servizio ordini: effettua ordini.
  • Rabbit MQ: coda di messaggi per gestire gli ordini.

Annotazioni

Non è consigliabile eseguire contenitori con stato, ad esempio Rabbit MQ, senza l'archiviazione permanente per la produzione. Questi vengono usati qui per semplicità, ma è consigliabile usare servizi gestiti, ad esempio Azure Cosmos DB o bus di servizio di Azure.

  1. Creare un file denominato aks-store-quickstart.yaml e copiarlo nel manifesto seguente:

    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
---
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
        resources:
          requests:
            cpu: 1m
            memory: 1Mi
          limits:
            cpu: 1m
            memory: 7Mi
---
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
---
apiVersion: v1
kind: Service
metadata:
  name: store-front
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: store-front
  type: LoadBalancer

  2. Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del manifesto YAML.

    kubectl apply -f aks-store-quickstart.yaml

Testare l'applicazione

È possibile convalidare che l'applicazione sia in esecuzione visitando l'indirizzo IP pubblico o l'URL dell'applicazione.

Ottenere l’URL dell'applicazione usando i comandi seguenti:

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: $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

echo "http://$IP_ADDRESS"

Eliminare il cluster

Se non intendi seguire le esercitazioni, elimina le risorse non necessarie per evitare addebiti di Azure.

Rimuovere il gruppo di risorse, il servizio contenitore e tutte le risorse correlate usando il comando az group delete.

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

Contenuti correlati

Per altre informazioni sull'ACL per il servizio Azure Kubernetes, vedere Che cos'è Azure Container Linux (ACL) per Servizio Azure Kubernetes (AKS)?

  • Last updated on