Esercizio - Distribuire un contenitore di microservizio in Kubernetes

7 minuti

Kubernetes esegue automaticamente i contenitori. Descrivere le operazioni che Kubernetes deve eseguire tramite un file YAML. Questo esercizio illustra come creare il file in modo da poter distribuire ed eseguire il servizio back-end in Kubernetes.

Importante

Prima di procedere, è necessario assicurarsi di avere installato un'implementazione di Kubernetes. Verrà usata l'implementazione k3d in esecuzione nello spazio di codice. 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 :

Nello spazio di codice 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 curl comando 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

Installare infine 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 dello spazio di codice 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 un paio di operazioni.

La prima parte definisce una specifica di distribuzione per il contenitore da distribuire in Kubernetes. Specifica una replica, dove trovare l'immagine del contenitore, quali porte aprire nel contenitore e imposta alcune variabili di ambiente. Questa prima parte definisce anche etichette e nomi che possono essere usati per fare riferimento al contenitore e alla specifica.

La seconda parte definisce quindi che il contenitore funziona 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

Quindi, distribuiamo ed eseguiamo il microservizio.

Nella scheda TERMINALE eseguire il comando seguente:
```
kubectl apply -f backend-deploy.yml
```
Questo comando indica a Kubernetes di eseguire il file creato. Scarica l'immagine dall'hub Docker e crea il contenitore.
Il kubectl apply comando viene restituito rapidamente. Tuttavia, la creazione del contenitore potrebbe richiedere del tempo. Per visualizzare lo stato di avanzamento, usare il codice seguente.
```
kubectl get pods
```
Nell'output risultante è presente una riga con productsbackend seguita da una stringa di caratteri casuali nella colonna NAME . Quando tutto è pronto, nella colonna READY è presente un valore 1/1 e In esecuzione nella colonna STATUS.
Per testare il servizio, passare alla scheda PORTE , accanto all'indirizzo locale per la porta Back-End , selezionare l'icona del globo. Il browser apre una nuova scheda in corrispondenza di tale indirizzo.

Per eseguire query su alcuni prodotti, aggiungere l'indirizzo con /api/product e quindi premere INVIO. Verranno visualizzate alcune informazioni sul prodotto 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 anche un file di distribuzione 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.

Si noti che questo file è simile a quello creato per il microservizio back-end. Esistono due differenze:
- Nel valore spec.template.spec.containers.image della distribuzione viene specificato un contenitore diverso da eseguire.
- Nella sezione è presente una nuova variabile spec.template.spec.containers.env di ambiente. Il codice nell'applicazione storefrontend chiama il back-end, ma poiché non è stato specificato un nome di dominio completo (FQDN), non si conosce l'indirizzo IP del microservizio back-end, viene usato il nome specificato nel metadata.name nodo di Deployment. Kubernetes si occupa del resto.
Distribuire il contenitore in Kubernetes con il comando seguente:
```
kubectl apply -f frontend-deploy.yml
```
Anche in questo caso è possibile usare kubectl get pods per visualizzare lo stato della distribuzione. Quando la riga per storefrontend visualizza In esecuzione sotto la colonna STATUS , tutto è pronto per l'esecuzione.
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 descrive esattamente come si vuole che i contenitori vengano eseguiti all'interno di Kubernetes. Kubernetes scarica quindi l'immagine dall'hub Docker e avvia i contenitori.

Commenti e suggerimenti

Questa pagina è stata utile?