(DEPRECATO) - Distribuire cluster Kubernetes per contenitori Linux

In questo argomento di avvio rapido viene distribuito un cluster Kubernetes con l'interfaccia della riga di comando di Azure. Un'applicazione multicontenitore costituita dal front-end Web e da un'istanza di Redis viene quindi distribuita ed eseguita nel cluster. Al termine, l'applicazione è accessibile tramite Internet.

L'applicazione di esempio usata in questo documento è scritta in Python. I concetti e i passaggi descritti possono essere usati per distribuire un'immagine del contenitore in un cluster Kubernetes. Il codice, Dockerfile, e il file manifesto di Kubernetes creato in precedenza per questo progetto sono disponibili in GitHub.

Questa guida introduttiva presuppone una conoscenza di base dei concetti relativi a Kubernetes. Per informazioni dettagliate in proposito, vedere la documentazione di Kubernetes.

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Azure Cloud Shell

Azure Cloud Shell è un ambiente di shell interattivo ospitato in Azure e usato tramite il browser. È possibile usare Bash o PowerShell con Cloud Shell per usare i servizi di Azure. È possibile usare i comandi preinstallati di Cloud Shell per eseguire il codice contenuto in questo articolo senza dover installare strumenti nell'ambiente locale.

Per avviare Azure Cloud Shell:

Opzione	Esempio/Collegamento
Selezionare Prova nell'angolo superiore destro di un blocco di codice o di comando. Quando si seleziona Prova, il codice o il comando non viene copiato automaticamente in Cloud Shell.
Passare a https://shell.azure.com o selezionare il pulsante Avvia Cloud Shell per aprire Cloud Shell nel browser.
Selezionare il pulsante Cloud Shell nella barra dei menu nell'angolo in alto a destra del portale di Azure.

Per usare Azure Cloud Shell:

1. Avviare Cloud Shell.

2. Selezionare il pulsante Copia in un blocco di codice (o in un blocco di comando) per copiare il codice o il comando.

3. Incollare il codice o il comando nella sessione di Cloud Shell selezionando CTRL+MAIUSC+V in Windows e Linux o selezionando CMD+MAIUSC+V in macOS.

4. Premere Invio per eseguire il codice o il comando.

Se si sceglie di installare e usare l'interfaccia della riga di comando in locale, per questa guida introduttiva è necessario eseguire la versione 2.0.4 o successiva dell'interfaccia della riga di comando di Azure. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

Creare un gruppo di risorse

Creare un gruppo di risorse con il comando az group create. Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite.

L'esempio seguente crea un gruppo di risorse denominato myResourceGroup nella località westeurope.

az group create --name myResourceGroup --location westeurope

Output:

{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup",
  "location": "westeurope",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Creare un cluster Kubernetes

Creare un cluster Kubernetes nel servizio Azure Container con il comando az acs create. L'esempio seguente crea un cluster denominato myK8sCluster con un nodo master Linux e tre nodi agente Linux.

az acs create --orchestrator-type kubernetes --resource-group myResourceGroup --name myK8sCluster --generate-ssh-keys

In alcuni casi la sottoscrizione di Azure ha accesso limitato alle risorse di Azure, ad esempio con una versione di valutazione gratuita limitata. Se la distribuzione non riesce a causa di core disponibili limitati, ridurre il numero di agenti predefinito aggiungendo --agent-count 1 al comando az acs create.

Dopo alcuni minuti, il comando viene completato e restituisce le informazioni in formato json sul cluster.

Stabilire la connessione al cluster

Per gestire un cluster Kubernetes, usare kubectl, il client da riga di comando di Kubernetes.

Se si usa Azure Cloud Shell, kubectl è già installato. Se lo si vuole installare in locale, è possibile usare il comando az acs kubernetes install-cli.

Per configurare kubectl per connettersi al cluster Kubernetes, eseguire il comando az acs kubernetes get-credentials. Con questo passaggio si scaricano le credenziali e si configura l'interfaccia della riga di comando di Kubernetes per il loro uso.

az acs kubernetes get-credentials --resource-group=myResourceGroup --name=myK8sCluster

Per verificare la connessione al cluster, usare il comando kubectl get per restituire un elenco di nodi del cluster.

kubectl get nodes

Output:

NAME                    STATUS                     AGE       VERSION
k8s-agent-14ad53a1-0    Ready                      10m       v1.6.6
k8s-agent-14ad53a1-1    Ready                      10m       v1.6.6
k8s-agent-14ad53a1-2    Ready                      10m       v1.6.6
k8s-master-14ad53a1-0   Ready,SchedulingDisabled   10m       v1.6.6

Eseguire l'applicazione

Un file manifesto di Kubernetes definisce uno stato desiderato per il cluster, incluse le immagini del contenitore da eseguire. Per questo esempio, viene usato un manifesto per creare tutti gli oggetti necessari per eseguire l'applicazione Azure Vote.

Creare un file denominato azure-vote.yml e copiarvi il codice YAML seguente. Se si usa Azure Cloud Shell, questo file può essere creato usando vi o Nano come se si usasse un sistema virtuale o fisico.

apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: azure-vote-back
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: azure-vote-back
    spec:
      containers:
      - name: azure-vote-back
        image: redis
        ports:
        - containerPort: 6379
          name: redis
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-back
spec:
  ports:
  - port: 6379
  selector:
    app: azure-vote-back
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: azure-vote-front
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: azure-vote-front
    spec:
      containers:
      - name: azure-vote-front
        image: microsoft/azure-vote-front:v1
        ports:
        - containerPort: 80
        env:
        - name: REDIS
          value: "azure-vote-back"
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-front
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: azure-vote-front

Usare il comando kubectl create per eseguire l'applicazione.

kubectl create -f azure-vote.yml

Output:

deployment "azure-vote-back" created
service "azure-vote-back" created
deployment "azure-vote-front" created
service "azure-vote-front" created

Testare l'applicazione

Mentre l'applicazione viene eseguita, viene creato un servizio di Kubernetes che espone il front-end dell'applicazione a Internet. Questo processo può richiedere alcuni minuti.

Per monitorare lo stato, usare il comando kubectl get service con l'argomento --watch.

kubectl get service azure-vote-front --watch

EXTERNAL-IP per il servizio azure-vote-front inizialmente viene visualizzato come pending. Dopo che l'indirizzo EXTERNAL-IP passa da pending a un indirizzo IP, usare CTRL-C per arrestare il processo kubectl watch.

azure-vote-front   10.0.34.242   <pending>     80:30676/TCP   7s
azure-vote-front   10.0.34.242   52.179.23.131   80:30676/TCP   2m

È ora possibile passare all'indirizzo IP esterno per visualizzare l'app Azure Vote.

Eliminare il cluster

Quando il cluster non è più necessario, è possibile usare il comando az group delete per rimuovere il gruppo di risorse, il servizio contenitore e tutte le risorse correlate.

az group delete --name myResourceGroup --yes --no-wait

Ottenere il codice

In questa guida introduttiva sono state usate immagini del contenitore già creato per creare una distribuzione di Kubernetes. Il codice dell'applicazione correlato, Dockerfile, e il file manifesto di Kubernetes sono disponibili su GitHub.

https://github.com/Azure-Samples/azure-voting-app-redis

Passaggi successivi

In questa guida introduttiva è stato distribuito un cluster Kubernetes in cui è stata quindi distribuita un'applicazione multicontenitore.

Per altre informazioni sul servizio Azure Container e l'analisi di un codice completo per la distribuzione dell'esempio, passare all'esercitazione sul cluster Kubernetes.