Configurazione del tuo primo cluster nel tuo VPC (Virtual Private Cloud)

Crea un cluster IBM Cloud® Kubernetes Service nel tuo Virtual Private Cloud (VPC).

Con i cluster di " IBM Cloud Kubernetes Service " su VPC, puoi creare il tuo cluster nella piattaforma di nuova generazione " IBM Cloud ", all'interno del tuo Virtual Private Cloud. VPC ti offre la sicurezza di un ambiente cloud privato con la scalabilità dinamica di un cloud pubblico. VPC utilizza la prossima versione di IBM Cloud Kubernetes Service fornitori di infrastrutture, con un insieme selezionato di funzionalità API, CLI e console di v2. Puoi creare solo cluster standard per VPC.

Destinatari

Questo tutorial è rivolto agli amministratori che stanno creando per la prima volta un cluster in IBM Cloud Kubernetes Service all'interno di una VPC.

Obiettivi

Nelle lezioni dell'esercitazione, crei un cluster IBM Cloud Kubernetes Service in un VPC (Virtual Private Cloud). Distribuisci quindi un'applicazione e la esponi pubblicamente utilizzando un programma di bilanciamento del carico.

Cosa otterrai

In questo tutorial creerai le seguenti risorse. Ci sono passi facoltativi per eliminare queste risorse se non si desidera conservarle dopo aver completato l'esercitazione.

Un cluster VPC
Una semplice applicazione Hello World distribuita al tuo cluster
Un programma di bilanciamento del carico VPC per esporre la tua applicazione

Prerequisiti

Completare la seguente procedura prerequisita per configurare le autorizzazioni e l'ambiente della riga comandi.

Autorizzazioni: Se sei il proprietario dell'account, hai già le autorizzazioni richieste per creare un cluster e puoi continuare con il passo successivo. Altrimenti, chiedi al proprietario dell'account di configurare la chiave API e assegnarti le autorizzazioni utente minime in IBM Cloud IAM.
Strumenti della linea di comando: Per un rapido accesso alle tue risorse dalla riga di comando, prova IBM Cloud Shell. In caso contrario, impostare l'ambiente della riga comandi locale completando la procedura riportata di seguito.

Installa la CLI IBM Cloud (ibmcloud), il plugin Kubernetes Service (ibmcloud ks) e il plugin IBM Cloud Container Registry (ibmcloud cr).
Installa Red Hat OpenShift(oc)e Kubernetes(kubectl)CLIs.
Per lavorare con VPC, installa il plugin infrastructure-service. Il prefisso per l'esecuzione dei comandi è ibmcloud is.
```
ibmcloud plugin install infrastructure-service
```
Aggiorna il tuo plugin Kubernetes Service alla versione più recente.
```
ibmcloud plugin update kubernetes-service
```
Assicurati che la versione kubectl corrisponda alla versione Kubernetes del tuo cluster VPC. Questo tutorial illustra come creare un cluster che esegue la versione 1.35.

Crea un cluster in VPC

Crea un cluster IBM Cloud Kubernetes Service nel tuo ambiente VPC (Virtual Private Cloud) IBM Cloud. Per ulteriori informazioni su VPC, vedi Introduzione a Virtual Private Cloud.

Accedi all'account, al gruppo di risorse e alla regione IBM Cloud in cui vuoi creare il tuo ambiente VPC. Il VPC deve essere configurato nella stessa regione metropolitana multizona in cui si desidera creare il cluster. In questa esercitazione, crei un VPC in us-south. Per le altre regioni supportate, vedi Aree metropolitane multizona per i cluster VPC. Se disponi di un ID federato, includi l'opzione --sso.
```
ibmcloud login -r us-south [-g <resource_group>] [--sso]
```

Crea un VPC per il tuo cluster. Per ulteriori informazioni, consulta la documentazione per la creazione di un VPC nella console o nella CLI.

Crea una VPC denominata “ myvpc ” e prendi nota dell’ID riportato nell’output. I VPC forniscono un ambiente isolato per i tuoi carichi di lavoro da eseguire all'interno del cloud pubblico. Puoi utilizzare lo stesso VPC per più cluster, come ad esempio se intendi avere dei cluster differenti che ospitano microservizi separati che devono comunicare tra loro. Se vuoi separare i tuoi cluster, come ad esempio per dipartimenti differenti, puoi creare un VPC per ciascun cluster.

    ibmcloud is vpc-create myvpc
    ```
2. Crea una sottorete per il tuo VPC e prendi nota del suo **ID**. Considera le seguenti informazioni quando crei la sottorete VPC;
    - **Zone**: devi avere una sottorete VPC per ciascuna zona nel tuo cluster. Le zone disponibili dipendono dall'area metropolitana in cui è stata creata la VPC. Per elencare le zone disponibili nella regione, esegui `ibmcloud is zones`.
    - **Indirizzi IP**: le sottoreti VPC forniscono gli indirizzi IP privati per i tuoi nodi di lavoro e per i tuoi servizi del programma di bilanciamento del carico nel tuo cluster, per cui assicurati di [creare una sottorete con un numero sufficiente di indirizzi IP](/docs/containers?topic=containers-vpc-subnets#vpc_basics_subnets), ad esempio 256. Non è possibile modificare in un secondo momento il numero di indirizzi IP di una sottorete VPC.
    - **Gateway pubblici**: non è necessario collegare un gateway pubblico per completare questo tutorial. Puoi invece tenere i tuoi nodi di lavoro isolati dall'accesso pubblico utilizzando i programmi di bilanciamento del carico VPC per esporre i carichi di lavoro in modo protetto. Puoi collegare un gateway pubblico se i tuoi nodi di lavoro devono accedere a un URL pubblico.

```sh {: pre}
    ibmcloud is subnet-create mysubnet1 VPC_ID --zone us-south-1 --ipv4-address-count 256
    ```

Crea un cluster nel tuo VPC nella stessa zona della sottorete. Per impostazione predefinita, il cluster viene creato con un endpoint di servizio cloud pubblico e uno privato. È possibile utilizzare l'endpoint del servizio cloud pubblico per accedere al master di Kubernetes, ad esempio per eseguire comandi kubectl, dal proprio computer locale. I nodi di lavoro possono comunicare con il master tramite l'endpoint del servizio cloud privato. Per ulteriori informazioni sulle opzioni del comando, vedi la documentazione di riferimento della CLI cluster create vpc-gen2.
```
ibmcloud ks cluster create vpc-gen2 --name myvpc-cluster --zone us-south-1 --version 1.35 --flavor bx2.2x8 --workers 1 --vpc-id VPC_ID --subnet-id VPC_SUBNET_ID
```

Controlla lo stato del tuo cluster. Il provisioning del cluster potrebbe richiedere qualche minuto.

Verifica che lo stato (State) del cluster sia normal.

    ibmcloud ks cluster ls --provider vpc-gen2
    ```
2. Scarica i file di configurazione di Kubernetes.
```sh {: pre}
    ibmcloud ks cluster config --cluster myvpc-cluster
    ```
3. Verifica che i comandi `kubectl` siano eseguiti correttamente con il tuo cluster controllando la versione server della CLI Kubernetes.
```sh {: pre}
    kubectl version  --short
    ```
    Output di esempio
    ```sh {: screen}
    Client Version: 1.35
    Server Version: 1.35+IKS
    ```

Distribuisci un'applicazione disponibile privatamente

Crea una distribuzione Kubernetes per distribuire una singola istanza dell'applicazione come un pod al tuo nodo di lavoro nel tuo cluster VPC.

Clona il codice sorgente dell'app "Hello world " nella tua directory home. Il repository contiene diverse versioni di un'applicazione simile nelle cartelle, ognuna delle quali inizia con Lab. Ogni versione contiene i seguenti file:
- Dockerfile: le definizioni di build dell'immagine.
- app.js: l'applicazione Hello world.
- package.json: i metadati dell'applicazione.
```
git clone https://github.com/IBM/container-service-getting-started-wt.git
```

Vai alla directory “ Lab 1 ”.

cd 'container-service-getting-started-wt/Lab 1'

Utilizza uno spazio dei nomi del registro esistente oppure creane uno, ad esempio vpc-gen2.
```
ibmcloud cr namespace-list
```
```
ibmcloud cr namespace-add vpc-gen2
```
Crea un'immagine Docker che include i file dell'applicazione della directory Lab 1.

Utilizza caratteri alfanumerici minuscoli o di sottolineatura (_) solo nei nomi di immagine. Non dimenticare il punto (.) alla fine del comando. Il punto indica a Docker di guardare all'interno della directory corrente per trovare il Dockerfile e le risorse di build per creare l'immagine.
```
docker build -t us.icr.io/<namespace>/hello-world:1 .
```
Quando la creazione è completa, verifica di ricevere il seguente messaggio di esito positivo:
```
=> exporting to image                                                                           0.0s
=> => exporting layers                                                                          0.0s
=> => writing image sha256:3ca1eb1d0998f738b552d4c435329edf731fe59e427555b78ba2fb54f2017906     0.0s
=> => naming to <region>.icr.io/<namespace>/hello-world:1                                       0.0s
```
Accedi a IBM Cloud Container Registry.
```
ibmcloud cr login
```
Esegui il push dell'immagine allo spazio dei nomi IBM Cloud Container Registry che hai creato. Se hai bisogno di modificare l'applicazione in futuro, ripeti questi passi per creare un'altra versione dell'immagine. Nota: acquisisci ulteriori informazioni sulla protezione delle tue informazioni personali quando utilizzi le immagini del contenitore.
```
docker push us.icr.io/<namespace>/hello-world:1
```
Crea una distribuzione per la tua applicazione. Le distribuzioni sono utilizzate per gestire i pod, che includono le istanze inserite nel contenitore di un'applicazione. Il seguente comando distribuisce l'applicazione in un singolo pod. Per gli scopi di questa esercitazione, la distribuzione viene denominata hello-world-deployment ma puoi fornirle qualsiasi nome tu voglia.
```
kubectl create deployment hello-world-deployment --image=us.icr.io/vpc-gen2/hello-world:1
```
Output di esempio
```
deployment.apps/hello-world-deployment created
```
Ulteriori informazioni sulla protezione delle tue informazioni personali quando utilizzi le risorse Kubernetes.

Rendi l'applicazione accessibile esponendo la distribuzione come un servizio NodePort. Poiché i tuoi nodi di lavoro VPC sono connessi solo a una sottorete privata, alla NodePort viene assegnato solo un indirizzo IP privato e non è esposto sulla rete pubblica. Gli altri servizi che vengono eseguiti sulla rete privata possono accedere alla tua applicazione utilizzando l'indirizzo IP privato del servizio NodePort.

kubectl expose deployment/hello-world-deployment --type=NodePort --name=hello-world-service --port=8080 --target-port=8080

Output di esempio

service/hello-world-service exposed

Informazioni sulle opzioni del comando.
Parametro	Descrizione
`expose`	Esponi una risorsa Kubernetes, come ad esempio una distribuzione, come un servizio Kubernetes in modo che gli utenti possano accedere alla risorsa utilizzando l'indirizzo IP del servizio.
`deployment/<hello-world-deployment>`	Il nome e il tipo della risorsa da esporre con questo servizio.
`--name=<hello-world-service>`	Il nome del servizio.
`--type=NodePort`	Il tipo di servizio da creare. In questa lezione, crei un servizio `NodePort`. Nella seguente lezione, crei un servizio `LoadBalancer`.
`--port=<8080>`	La porta su cui il servizio è in ascolto per il traffico di rete esterno.
`--target-port=<8080>`	La porta su cui la tua applicazione è in ascolto e a cui il servizio indirizza il traffico di rete in entrata. In questo esempio, la `target-port` è uguale alla `port` ma le altre applicazioni che crei potrebbero utilizzare una porta differente.

Ora che tutto il lavoro di distribuzione è stato effettuato, puoi testare la tua applicazione dall'interno del cluster. Ottieni i dettagli per formare l'indirizzo IP privato che puoi utilizzare per accedere alla tua applicazione.

Ottieni le informazioni sul servizio per visualizzare quale NodePort è stata assegnata. Le NodePort sono assegnate casualmente quando vengono generate con il comando expose, ma comprese nell'intervallo 30000-32767. In questo esempio, la NodePort è 30872.

    kubectl describe service hello-world-service
    ```
    Output di esempio

    ```sh {: screen}
    NAME:                   hello-world-service
    Namespace:              default
    Labels:                 run=hello-world-deployment
    Selector:               run=hello-world-deployment
    Type:                   NodePort
    IP:                     10.xxx.xx.xxx
    Port:                   <unset> 8080/TCP
    NodePort:               <unset> 30872/TCP
    Endpoints:              172.30.xxx.xxx:8080
    Session Affinity:       None
    No events.
    ```
2. Elenca i pod che eseguono la tua applicazione e prendi nota del nome del pod.
```sh {: pre}
    kubectl get pods
    ```
    Output di esempio
    ```sh {: screen}
    NAME                                     READY     STATUS        RESTARTS   AGE
    hello-world-deployment-d99cddb45-lmj2v   1/1       Running       0          2d
    ```
3. Descrivi il tuo pod per scoprire quale sia il nodo di lavoro su cui è in esecuzione il pod. Nell'output di esempio, il nodo di lavoro su cui è in esecuzione il pod è **10.xxx.xx.xxx**.
```sh {: pre}
    kubectl describe pod hello-world-deployment-d99cddb45-lmj2v
    ```
    Output di esempio

    ```sh {: screen}
    NAME:               hello-world-deployment-d99cddb45-lmj2v
    Namespace:          default
    Priority:           0
    PriorityClassName:  <none>
    Node:               10.xxx.xx.xxx/10.xxx.xx.xxx
    Start Time:         Mon, 22 Apr 20122 12:40:48 -0400
    Labels:             pod-template-hash=d99cddb45
                        run=hello-world-deployment
    Annotations:        kubernetes.io/psp=ibm-privileged-psp
    Status:             Running
    IP:                 172.30.xxx.xxx
    ...
    ```

Accedi al pod in modo da poter effettuare una richiesta alla tua applicazione dall'interno del cluster.
```
kubectl exec -it hello-world-deployment-d99cddb45-lmj2v /bin/sh
```

Effettua una richiesta al servizio NodePort utilizzando l'indirizzo IP privato del nodo di lavoro e la porta del nodo che hai richiamato in precedenza.

wget -O - 10.xxx.xx.xxx:30872

Output di esempio

Connecting to 10.xxx.xx.xxx:30872 (10.xxx.xx.xxx:30872)
Hello world from hello-world-deployment-d99cddb45-lmj2v! Your app is up and running in a cluster!
-                    100% |*****************************************************************************************|    88   0:00:00 ETA

Per chiudere la tua sessione del pod, immetti exit.

Configura un programma di bilanciamento del carico per VPC per esporre la tua applicazione pubblicamente

Configura un programma di bilanciamento del carico VPC per esporre la tua applicazione sulla rete pubblica.

Quando crei un servizio LoadBalancer Kubernetes nel tuo cluster, un programma di bilanciamento del carico per VPC viene creato automaticamente nel tuo VPC esternamente al tuo cluster, Il programma di bilanciamento del carico è multizona e instrada le richieste per la tua applicazione tramite le NodePort private che vengono automaticamente aperte sui tuoi nodi di lavoro. Il seguente diagramma illustra il modo in cui un utente accede al servizio di un'applicazione tramite il programma di bilanciamento del carico, anche se il tuo nodo di lavoro è connesso solo a una sottorete privata.

Bilanciamento del carico VPC per un cluster. — Bilanciamento del carico VPC per un cluster

Crea un servizio LoadBalancer Kubernetes nel tuo cluster per esporre pubblicamente l'applicazione hello world.

kubectl expose deployment/hello-world-deployment --type=LoadBalancer --name=hw-lb-svc  --port=8080 --target-port=8080

Output di esempio

service "hw-lb-svc" exposed

Informazioni sulle opzioni del comando.
Parametro	Descrizione
`expose`	Esponi una risorsa Kubernetes, come ad esempio una distribuzione, come un servizio Kubernetes in modo che gli utenti possano accedere alla risorsa utilizzando l'indirizzo IP del servizio.
`deployment/<hello-world-deployment>`	Il nome e il tipo della risorsa da esporre con questo servizio.
`--name=<hello-world-service>`	Il nome del servizio.
`--type=LoadBalancer`	Il tipo di servizio Kubernetes da creare. In questa lezione, crei un servizio `LoadBalancer`.
`--port=<8080>`	La porta su cui il servizio è in ascolto per il traffico di rete esterno.
`--target-port=<8080>`	La porta su cui la tua applicazione è in ascolto e a cui il servizio indirizza il traffico di rete in entrata. In questo esempio, la `target-port` è uguale alla `port` ma le altre applicazioni che crei potrebbero utilizzare una porta differente.

Verifica che il servizio LoadBalancer Kubernetes sia stato creato correttamente nel tuo cluster. Quando crei il servizio LoadBalancer Kubernetes, per te viene creato automaticamente un programma di bilanciamento del carico VPC. Il programma di bilanciamento del carico VPC assegna un nome host al tuo servizio LoadBalancer Kubernetes che puoi vedere nel campo LoadBalancer Ingress del tuo output della CLI. Il programma di bilanciamento del carico VPC impiega qualche minuto ad eseguire il provisioning nel tuo VPC. Finché il bilanciatore di carico VPC non sarà pronto, non sarà possibile accedere al servizio Kubernetes LoadBalancer tramite il suo nome host.

kubectl describe service hw-lb-svc

Output CLI di esempio

NAME:                     hw-lb-svc
Namespace:                default
Labels:                   app=hello-world-deployment
Annotations:              <none>
Selector:                 app=hello-world-deployment
Type:                     LoadBalancer
IP:                       172.21.xxx.xxx
LoadBalancer Ingress:     1234abcd-us-south.lb.appdomain.cloud
Port:                     <unset> 8080/TCP
TargetPort:               8080/TCP
NodePort:                 <unset> 32040/TCP
Endpoints:
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
    Type    Reason                Age   From                Message
    ----    ------                ----  ----                -------
    Normal  EnsuringLoadBalancer  1m    service-controller  Ensuring load balancer
    Normal  EnsuredLoadBalancer   1m    service-controller  Ensured load balancer

Verifica che il programma di bilanciamento del carico VPC sia stato creato correttamente nel tuo VPC. Nell'output, verifica che il programma di bilanciamento del carico VPC abbia uno Stato di provisioning di active e uno Stato operativo di online.

Il bilanciatore di carico VPC è denominato secondo il formato kube-<cluster_ID>-<kubernetes_lb_service_UID>. Per visualizzare l'ID del cluster, esegui il comando ibmcloud ks cluster get --cluster CLUSTER_NAME``. Per visualizzare l'IUD del servizio LoadBalancer Kubernetes, esegui kubectl get svc hw-lb-svc -o yaml e cerca il campo metadata.uid nell'output.
```
ibmcloud is load-balancers
```
Nell'esempio seguente, che riporta l'output della CLI, viene creato il bilanciatore di carico VPC denominato " kube-bsaucubd07dhl66e4tgg-1f4f408ce6d2485499bcbdec0fa2d306 " per il servizio " Kubernetes " LoadBalancer:
```
ID                                          Name                                                         Family        Subnets               Is public   Provision status   Operating status   Resource group
r006-d044af9b-92bf-4047-8f77-a7b86efcb923   kube-bsaucubd07dhl66e4tgg-1f4f408ce6d2485499bcbdec0fa2d306   Application   mysubnet-us-south-3   true        active             online             default
```
Invia una richiesta alla tua app utilizzando curl con il nome host e la porta del servizio Kubernetes LoadBalancer assegnato dal bilanciatore di carico VPC che hai individuato nel passaggio 2.
```
curl 1234abcd-us-south.lb.appdomain.cloud:8080
```
Output di esempio
```
Hello world from hello-world-deployment-5fd7787c79-sl9hn! Your app is up and running in a cluster!
```

Operazioni successive

Ora che hai un cluster VPC, impara di più su quello che puoi fare.

Hai bisogno di aiuto, hai domande o vuoi dare un feedback sui cluster VPC? Prova a pubblicare nel canale Slack.