Esercizio - Distribuire un contenitore di microservizio in Kubernetes

7 minuti

Kubernetes esegue automaticamente i contenitori. Per descrivere le operazioni che Kubernetes deve eseguire, si usa un file YAML. Questo esercizio illustra la creazione del file per poter distribuire ed eseguire il servizio back-end in Kubernetes.

Importante

Prima di procedere, è necessario assicurarsi che sia installata un'implementazione di Kubernetes. Verrà usata l'implementazione k3d in esecuzione nel codespace. Verrà avviato il lab installando questa implementazione.

Installare gli strumenti e l'implementazione di Kubernetes

È necessario installare sia lo strumento kubectl che l'implementazione di Kubernetes k3d:

Nel codespace, passare alla scheda TERMINALE e quindi eseguire questi comandi per installare i prerequisiti:
```
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
```
Successivamente, per scaricare la chiave di firma per i repository dei pacchetti Kubernetes, eseguire questi comandi:
```
sudo mkdir /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
```
Se viene visualizzato un errore che indica che la directory esiste già, eseguire il comando curl separatamente.

Aggiungere il repository Kubernetes alla configurazione apt:

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

È ora possibile installare lo strumento kubectl :

sudo apt-get update
sudo apt-get install -y kubectl

Infine, installare l'implementazione k3d di Kubernetes e creare un cluster:

curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
k3d cluster create devcluster --config k3d.yml

Creare un file di distribuzione per il servizio back-end

È possibile creare un file per gestire la distribuzione di contenitori in Kubernetes con un file YAML. Verrà ora creato un file per distribuire il servizio back-end.

Creare un nuovo file nella cartella donet-kubernetes del codespace denominato backend-deploy.yml.

Copiare il testo seguente nel file e quindi salvarlo.

---
apiVersion: apps/v1
kind: Deployment
metadata:
    name: productsbackend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: productsbackend
    spec:
      containers:
      - name: productsbackend
        image: [YOUR DOCKER USER NAME]/productservice:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
  selector:
    matchLabels:
      app: productsbackend
---
apiVersion: v1
kind: Service
metadata:
  name: productsbackend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32001
  selector:
    app: productsbackend

Sostituire il segnaposto [YOUR DOCKER USER NAME] con il nome utente Docker effettivo.

Questo file esegue due operazioni.

La prima parte definisce una specifica della distribuzione per il contenitore da distribuire in Kubernetes. Specifica una replica, dove trovare l'immagine del contenitore e quali porte aprire nel contenitore e imposta alcune variabili di ambiente. Questa prima parte definisce anche le etichette e i nomi con cui è possibile fare riferimento al contenitore e alla specifica.

La seconda parte definisce quindi che il contenitore viene eseguito come servizio NodePort di Kubernetes. Per questo modulo, non è necessario comprendere tutte le specifiche di NodePorts. Tuttavia, è necessario sapere che questo tipo di servizio espone un indirizzo IP esterno, in modo da poter testare il servizio dall'esterno del cluster.

Distribuire ed eseguire il microservizio back-end

Il microservizio verrà ora distribuito ed eseguito.

Nella schedaTERMINALE, eseguire il comando seguente:
```
kubectl apply -f backend-deploy.yml
```
Questo comando indica a Kubernetes di eseguire il file creato. Scarica l'immagine da Docker Hub e crea il contenitore.
Il comando kubectl apply viene restituito rapidamente, ma la creazione del contenitore può richiedere tempo. Per visualizzare l'avanzamento, usare il codice seguente.
```
kubectl get pods
```
Nell'output risultante, è presente una riga con il testo productsbackend seguito da una stringa di caratteri casuali nella colonna NOME. Quando tutto sarà pronto, la colonna PRONTI conterrà 1/1 e la colonna STATO conterrà In esecuzione.
Per testare il servizio, passare alla scheda PORTE e poi, vicino all'indirizzo locale per la porta Back End, selezionare l'icona a forma di globo. Il browser apre l'indirizzo corrispondente in una nuova scheda.

Per eseguire query su alcuni prodotti, aggiungere /api/product in fondo all'indirizzo e quindi premere INVIO. Dovrebbero essere visualizzate delle informazioni sui prodotti elencate in formato JSON.

[
    {
        "id": 1,
        "name": "Solar Powered Flashlight",
        "description": "A fantastic product for outdoor enthusiasts",
        "price": 19.99,
        "imageUrl": "product1.png"
    },
    {
        "id": 2,
        "name": "Hiking Poles",
        "description": "Ideal for camping and hiking trips",
        "price": 24.99,
        "imageUrl": "product2.png"
    },
    {
        "id": 3,
        "name": "Outdoor Rain Jacket",
        "description": "This product will keep you warm and dry in all weathers",
        "price": 49.99,
        "imageUrl": "product3.png"
    },
    ...

Creare un file di distribuzione ed eseguire il servizio front-end

Analogamente al servizio back-end, è necessario un file di distribuzione anche per il front-end.

Creare un nuovo file nella cartella donet-kubernetes denominata frontend-deploy.yml

Incollare il codice seguente nel file:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: storefrontend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: storefrontend
    spec:
      containers:
      - name: storefrontend
        image: [YOUR DOCKER USER NAME]/storeimage:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
        - name: ProductEndpoint
          value: http://productsbackend
  selector:
    matchLabels:
      app: storefrontend
---
apiVersion: v1
kind: Service
metadata:
  name: storefrontend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32000
  selector:
    app: storefrontend

Sostituire il segnaposto [YOUR DOCKER USERNAME] con il nome utente Docker effettivo.

Notare che questo file è simile a quello creato per il microservizio back-end. Sono presenti due differenze:
- Nel valore spec.template.spec.containers.image della distribuzione viene specificato un contenitore diverso da eseguire.
- Nella sezione spec.template.spec.containers.env è presente una nuova variabile di ambiente. Il codice nell'applicazione storefrontend chiama il back-end, ma, poiché non è specificato un nome di dominio completo (FQDN) né si conosce l'indirizzo IP del microservizio back-end, viene usato il nome specificato nel nodo metadata.name di Deployment. Kubernetes si occupa del resto.
Distribuire il contenitore in Kubernetes con il comando seguente:
```
kubectl apply -f frontend-deploy.yml
```
Ancora una volta, è possibile usare kubectl get pods per visualizzare lo stato della distribuzione. Quando la riga per storefrontend visualizza In esecuzione nella colonna STATO, è tutto pronto.
Per testare il servizio, passare alla scheda PORTE e poi, a destra dell'indirizzo locale per la porta Front End, selezionare l'icona a forma di globo. Il browser visualizza la home page.
Seleziona i prodotti. Il catalogo mostra la merce di Contoso.

In questo esercizio è stato creato un file di distribuzione che ha descritto esattamente come si voleva che i contenitori venissero eseguiti in Kubernetes, quindi si è impostato Kubernetes per il download dell'immagine da Docker Hub e l'avvio dei contenitori.

Continua

Esercizio - Distribuire un contenitore di microservizio in Kubernetes

Installare gli strumenti e l'implementazione di Kubernetes

Creare un file di distribuzione per il servizio back-end

Distribuire ed eseguire il microservizio back-end

Creare un file di distribuzione ed eseguire il servizio front-end

Commenti e suggerimenti