Avvio rapido: distribuire un cluster del servizio Azure Kubernetes con un modello di Resource Manager
Il servizio Azure Kubernetes è un servizio Kubernetes gestito che permette di distribuire e gestire rapidamente i cluster. Questa guida introduttiva spiega come:
- Distribuire un cluster del servizio Azure Kubernetes con un modello di Azure Resource Manager.
- Eseguire un'applicazione multi-contenitore di esempio con un gruppo di microservizi e front-end web, simulando uno scenario di vendita al dettaglio.
Un modello di Azure Resource Manager è un file JSON (JavaScript Object Notation) che definisce l'infrastruttura e la configurazione del progetto. Il modello utilizza la sintassi dichiarativa. Si descrive la distribuzione prevista senza scrivere la sequenza di comandi di programmazione necessari per creare la distribuzione.
Nota
Per iniziare ad effettuare un veloce provisioning di un cluster del servizio Azure Kubernetes, questo articolo include i passaggi per la distribuzione di un cluster con impostazioni predefinite a solo scopo di valutazione. Prima di distribuire un cluster pronto per la produzione, è consigliabile acquisire familiarità con l'architettura di riferimento di base per valutare il modo in cui è allineato ai requisiti aziendali.
Operazioni preliminari
Questo articolo presuppone una conoscenza di base dei concetti relativi a Kubernetes. Per altre informazioni, vedere Concetti di base relativi a Kubernetes per il servizio Azure Kubernetes.
-
Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.
Assicurarsi che l'identità usata per creare il cluster disponga delle autorizzazioni minime appropriate. Per maggiori informazioni sull'accesso e l'identità per il servizio Azure Kubernetes, vedere Opzioni di accesso e identità per il servizio Azure Kubernetes (AKS).
Per distribuire un modello di Resource Manager, è necessario l'accesso in scrittura alle risorse distribuite e l'accesso a tutte le operazioni sul tipo di risorsa
Microsoft.Resources/deployments. Ad esempio, per distribuire una macchina virtuale, sono necessarie le autorizzazioniMicrosoft.Compute/virtualMachines/writeeMicrosoft.Resources/deployments/*. Per un elenco dei ruoli e delle autorizzazioni, vedere Ruoli predefiniti di Azure.
Dopo aver distribuito il cluster dal modello, è possibile usare l'interfaccia della riga di comando di Azure o Azure PowerShell per connettersi al cluster e distribuire l'applicazione di esempio.
Usare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Avvio rapido su Bash in Azure Cloud Shell.
Se si preferisce eseguire i comandi di riferimento dell'interfaccia della riga di comando in locale, installare l'interfaccia della riga di comando di Azure. Per l'esecuzione in Windows o macOS, è consigliabile eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker.
Se si usa un'installazione locale, accedere all'interfaccia della riga di comando di Azure con il comando az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Accedere tramite l'interfaccia della riga di comando di Azure.
Quando richiesto, al primo utilizzo installare l'estensione dell'interfaccia della riga di comando di Azure. Per altre informazioni sulle estensioni, vedere Usare le estensioni con l'interfaccia della riga di comando di Azure.
Eseguire az version per trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, eseguire az upgrade.
Questo articolo richiede l'interfaccia della riga di comando di Azure 2.0.64 o versioni successive. Se si sta usando Azure Cloud Shell, la versione più recente è già installata.
Creare una coppia di chiavi SSH
Per creare un cluster del servizio Azure Kubernetes usando un modello di Resource Manager, è necessario specificare una chiave pubblica SSH. Se è necessaria questa risorsa, seguire la procedura descritta in questa sezione. In caso contrario, passare direttamente alla sezione Esamina il modello .
Per accedere ai nodi del servizio Azure Kubernetes, è necessario connettersi tramite una coppia di chiavi SSH (pubblica e privata). Per creare una coppia di chiavi SSH:
Passare a https://shell.azure.com per aprire Cloud Shell nel browser.
Creare una coppia di chiavi SSH usando il comando az sshkey create oppure il comando
ssh-keygen.# Create an SSH key pair using Azure CLI az sshkey create --name "mySSHKey" --resource-group "myResourceGroup" # or # Create an SSH key pair using ssh-keygen ssh-keygen -t rsa -b 4096Per distribuire il modello, è necessario fornire la chiave pubblica dalla coppia SSH. Per recuperare la chiave pubblica, chiamare az sshkey show:
az sshkey show --name "mySSHKey" --resource-group "myResourceGroup" --query "publicKey"
Per impostazione predefinita, questi file della chiave SSH vengono creati nella directory ~/.ssh. L'esecuzione del comando az sshkey create o ssh-keygen sovrascriverà qualsiasi coppia di chiavi SSH esistente con lo stesso nome.
Per altre informazioni su come creare le chiavi SSH, vedere Creare e gestire chiavi SSH per l'autenticazione in una macchina virtuale Linux in Azure.
Rivedere il modello
Il modello usato in questo avvio rapido proviene dai modelli di avvio rapido di Azure.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"metadata": {
"_generator": {
"name": "bicep",
"version": "0.26.170.59819",
"templateHash": "14823542069333410776"
}
},
"parameters": {
"clusterName": {
"type": "string",
"defaultValue": "aks101cluster",
"metadata": {
"description": "The name of the Managed Cluster resource."
}
},
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]",
"metadata": {
"description": "The location of the Managed Cluster resource."
}
},
"dnsPrefix": {
"type": "string",
"metadata": {
"description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
}
},
"osDiskSizeGB": {
"type": "int",
"defaultValue": 0,
"minValue": 0,
"maxValue": 1023,
"metadata": {
"description": "Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize."
}
},
"agentCount": {
"type": "int",
"defaultValue": 3,
"minValue": 1,
"maxValue": 50,
"metadata": {
"description": "The number of nodes for the cluster."
}
},
"agentVMSize": {
"type": "string",
"defaultValue": "standard_d2s_v3",
"metadata": {
"description": "The size of the Virtual Machine."
}
},
"linuxAdminUsername": {
"type": "string",
"metadata": {
"description": "User name for the Linux Virtual Machines."
}
},
"sshRSAPublicKey": {
"type": "string",
"metadata": {
"description": "Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example 'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm'"
}
}
},
"resources": [
{
"type": "Microsoft.ContainerService/managedClusters",
"apiVersion": "2024-02-01",
"name": "[parameters('clusterName')]",
"location": "[parameters('location')]",
"identity": {
"type": "SystemAssigned"
},
"properties": {
"dnsPrefix": "[parameters('dnsPrefix')]",
"agentPoolProfiles": [
{
"name": "agentpool",
"osDiskSizeGB": "[parameters('osDiskSizeGB')]",
"count": "[parameters('agentCount')]",
"vmSize": "[parameters('agentVMSize')]",
"osType": "Linux",
"mode": "System"
}
],
"linuxProfile": {
"adminUsername": "[parameters('linuxAdminUsername')]",
"ssh": {
"publicKeys": [
{
"keyData": "[parameters('sshRSAPublicKey')]"
}
]
}
}
}
}
],
"outputs": {
"controlPlaneFQDN": {
"type": "string",
"value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2024-02-01').fqdn]"
}
}
}
Il tipo di risorsa definita nel modello di Resource Manager è Microsoft.ContainerService/managedClusters.
Per altri esempi per il servizio Azure Kubernetes, vedere il sito dei modelli di avvio rapido per il servizio Azure Kubernetes.
Distribuire il modello
Selezionare Distribuisci in Azure per accedere e aprire il modello.
Nella pagina Informazioni di base, lasciare i valori predefiniti per GB delle dimensioni disco del sistema operativo, Numero di agenti, dimensione macchina virtuale agente e tipo di sistema operativo, nonché configurare i parametri del modello seguenti:
- Sottoscrizione: selezionare una sottoscrizione di Azure.
- Gruppo di risorse: selezionare Crea nuovo. Specificare un nome univoco per il gruppo di risorse, ad esempio myResourceGroup, quindi scegliere OK.
- Località: selezionare una località, ad esempio Stati Uniti orientali.
- Nome cluster: immettere un nome univoco per il cluster del servizio Azure Kubernetes, ad esempio myAKSCluster.
- Prefisso DNS: immettere un prefisso DNS univoco per il cluster, ad esempio myakscluster.
- Nome utente amministratore Linux: immettere un nome utente per connettersi tramite SSH, ad esempio azureuser.
- Origine chiave pubblica SSH: selezionare Usa chiave pubblica esistente.
- Nome della coppia di chiavi: copiare e incollare la parte pubblica della coppia di chiavi SSH (per impostazione predefinita, il contenuto di ~/.ssh/id_rsa.pub).
Selezionare Rivedi e crea>Crea.
Per creare il cluster del servizio Azure Kubernetes sono necessari alcuni minuti. Attendere il completamento della distribuzione del cluster prima di procedere al passaggio successivo.
Stabilire la connessione al cluster
Per gestire un cluster Kubernetes, usare il client da riga di comando kubernetes kubectl.
Se si usa Azure Cloud Shell, kubectl è già installato. Per installare ed eseguire kubectl localmente, chiamare il comando az aks install-cli.
Configurare
kubectlper 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 usarli.az aks get-credentials --resource-group myResourceGroup --name myAKSClusterVerificare la connessione al cluster usando il comando kubectl get. Questo comando restituisce un elenco dei nodi del cluster.
kubectl get nodesL'output di esempio seguente mostra i tre nodi creati nei passaggi precedenti. Assicurarsi che lo stato del nodo sia Pronto.
NAME STATUS ROLES AGE VERSION aks-agentpool-27442051-vmss000000 Ready agent 10m v1.27.7 aks-agentpool-27442051-vmss000001 Ready agent 10m v1.27.7 aks-agentpool-27442051-vmss000002 Ready agent 11m v1.27.7
Distribuire l'applicazione
Per distribuire l'applicazione, usare un file manifesto per creare tutti gli oggetti necessari per eseguire l'applicazione di Archiviazione del servizio Azure Kubernetes. 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:
- Front-store: applicazione Web per i clienti per visualizzare i prodotti ed effettuare ordini.
- Servizio prodotto: mostra le informazioni sul prodotto.
- Servizio ordini: effettua ordini.
- Rabbit MQ: coda di messaggi per una coda di ordini.
Nota
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 CosmosDB o il bus di servizio di Azure.
Creare un file denominato
aks-store-quickstart.yamle copiarlo nel manifesto seguente:apiVersion: apps/v1 kind: Deployment metadata: name: rabbitmq spec: 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 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 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: LoadBalancerPer un dettaglio dei file manifesto YAML, vedere Distribuzioni e manifesti YAML.
Se si crea e si salva il file YAML in locale, è possibile caricare il file manifesto nella directory predefinita in CloudShell facendo clic sul pulsante Carica/Scarica file e selezionando il file dal file system locale.
Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del manifesto YAML.
kubectl apply -f aks-store-quickstart.yamlL'output di esempio seguente mostra le distribuzioni e i servizi:
deployment.apps/rabbitmq created service/rabbitmq created deployment.apps/order-service created service/order-service created deployment.apps/product-service created service/product-service created deployment.apps/store-front created service/store-front created
Testare l'applicazione
Controllare lo stato dei pod distribuiti usando il comando kubectl get pods. Fare in modo che tutti i pod siano
Runningprima di procedere.kubectl get podsVerificare la presenza di un indirizzo IP pubblico per l'applicazione front-store. Monitorare lo stato usando il comando kubectl get service con l'argomento
--watch.kubectl get service store-front --watchL'output EXTERNAL-IP per il servizio
store-frontinizialmente viene visualizzato come in sospeso:NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE store-front LoadBalancer 10.0.100.10 <pending> 80:30025/TCP 4h4mQuando l'indirizzo EXTERNAL-IP passa da in sospeso a un effettivo indirizzo IP pubblico, usare
CTRL-Cper arrestare il processo di controllokubectl.L'output di esempio seguente mostra un indirizzo IP pubblico valido assegnato al servizio:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE store-front LoadBalancer 10.0.100.10 20.62.159.19 80:30025/TCP 4h5mAprire un Web browser all'indirizzo IP esterno del servizio per visualizzare l'app di Azure Store in azione.
Eliminare il cluster
Se non si prevede di eseguire l'esercitazione del servizio Azure Kubernetes, ripulire le risorse non necessarie per evitare addebiti di Azure.
Rimuovere il gruppo di risorse, il servizio contenitore e tutte le risorse correlate chiamando il comando az group delete.
az group delete --name myResourceGroup --yes --no-wait
Nota
Il cluster del servizio Azure Kubernetes è stato creato con un'identità gestita assegnata dal sistema, che è l'opzione di identità predefinita usata in questo avvio rapido. Questa identità è gestita dalla piattaforma, pertanto non è necessario rimuoverla manualmente.
Passaggi successivi
In questa guida introduttiva, è stato distribuito un cluster Kubernetes, successivamente è stata distribuita una semplice applicazione multi-contenitore. Questa applicazione di esempio è solo a scopo dimostrativo e non rappresenta tutte le procedure consigliate per le applicazioni Kubernetes. Per indicazioni sulla creazione di soluzioni complete con il servizio Azure Kubernetes per la produzione, vedere Linee guida per le soluzioni del servizio Azure Kubernetes.
Per altre informazioni sul servizio Azure Kubernetes e per un esempio completo di distribuzione del codice, passare all'esercitazione sul cluster Kubernetes.
Azure Kubernetes Service