Versione 1.6. Questa versione non è più supportata come descritto nelle norme relative al supporto delle versioni di Anthos. Per le patch e gli aggiornamenti più recenti per vulnerabilità di sicurezza, esposizioni e problemi che interessano i cluster Anthos su VMware (GKE on-prem), esegui l'upgrade a una versione supportata. La versione più recente è disponibile qui.

Versioni disponibili

Deployment di un'applicazione

Questo documento mostra come eseguire il deployment di un'applicazione nel cluster utente per i cluster Anthos su VMware (GKE on-prem).

Prima di iniziare

Crea un cluster utente (guida rapida | istruzioni complete).

Accedi alla workstation mediante SSH

Accedi alla workstation mediante SSH:

ssh -i ~/.ssh/vsphere_workstation ubuntu@[IP_ADDRESS]

dove [IP_ADDRESS] è l'indirizzo IP della workstation di amministrazione.

Esegui tutti i passaggi rimanenti di questo argomento sulla tua workstation di amministrazione.

Creazione di un deployment

Ecco un manifest per un deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  selector:
    matchLabels:
      app: metrics
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: metrics
        department: sales
    spec:
      containers:
      - name: hello
        image: "gcr.io/google-samples/hello-app:2.0"

Copia il manifest in un file denominato my-deployment.yaml e crea il deployment:

kubectl apply --kubeconfig [USER_CLUSTER_KUBECONFIG] -f my-deployment.yaml

dove [USER_CLUSTER_KUBECONFIG] è il percorso del file kubeconfig per il tuo cluster utente.

Informazioni di base sul tuo deployment:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] get deployment my-deployment

L'output mostra che il deployment ha tre pod tutti disponibili:

NAME            READY   UP-TO-DATE   AVAILABLE   AGE
my-deployment   3/3     3            3           27s

Elenca i pod presenti nel tuo deployment:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] get pods

L'output mostra che il deployment ha tre pod in esecuzione:

NAME                             READY   STATUS    RESTARTS   AGE
my-deployment-54944c8d55-4srm2   1/1     Running   0          6s
my-deployment-54944c8d55-7z5nn   1/1     Running   0          6s
my-deployment-54944c8d55-j62n9   1/1     Running   0          6s

Ottieni informazioni dettagliate sul deployment:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] get deployment my-deployment --output yaml

L'output mostra i dettagli relativi alle specifiche e allo stato del deployment:

kind: Deployment
metadata:
  ...
  generation: 1
  name: my-deployment
  namespace: default
  ...
spec:
  ...
  replicas: 3
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: metrics
      department: sales
  ...
    spec:
      containers:
      - image: gcr.io/google-samples/hello-app:2.0
        imagePullPolicy: IfNotPresent
        name: hello
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
status:
  availableReplicas: 3
  conditions:
  - lastTransitionTime: "2019-11-11T18:44:02Z"
    lastUpdateTime: "2019-11-11T18:44:02Z"
    message: Deployment has minimum availability.
    reason: MinimumReplicasAvailable
    status: "True"
    type: Available
  - lastTransitionTime: "2019-11-11T18:43:58Z"
    lastUpdateTime: "2019-11-11T18:44:02Z"
    message: ReplicaSet "my-deployment-54944c8d55" has successfully progressed.
    reason: NewReplicaSetAvailable
    status: "True"
    type: Progressing
  observedGeneration: 1
  readyReplicas: 3
  replicas: 3
  updatedReplicas: 3

Descrivi il tuo deployment:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] describe deployment my-deployment

L'output mostra dettagli ben formattati sul deployment, incluso il ReplicaSet associato:

Name:                   my-deployment
Namespace:              default
CreationTimestamp:      Mon, 11 Nov 2019 10:43:58 -0800
Labels:                 
...
Selector:               app=metrics,department=sales
Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=metrics
           department=sales
  Containers:
   hello:
    Image:        gcr.io/google-samples/hello-app:2.0
    Port:         
    Host Port:    
    Environment:  
    Mounts:       
  Volumes:        
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  
NewReplicaSet:   my-deployment-54944c8d55 (3/3 replicas created)

Creazione di un servizio di tipo LoadBalancer

Un modo per esporre il deployment ai client al di fuori del cluster è creare un servizio Kubernetes di tipo LoadBalancer.

Ecco un manifest per un servizio di tipo LoadBalancer:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: metrics
    department: sales
  type: LoadBalancer
  loadBalancerIP: [SERVICE_IP_ADDRESS]
  ports:
  - port: 80
    targetPort: 8080

Per le finalità di questo esercizio, ecco alcuni aspetti importanti relativi al Servizio:

Qualsiasi pod con l'etichetta app: metrics e l'etichetta department: sales è un membro del Servizio. Tieni presente che i pod in my-deployment hanno queste etichette.
Quando un client invia una richiesta al servizio sulla porta TCP 80, la richiesta viene inoltrata a un pod membro sulla porta TCP 8080.
Ogni pod membro deve avere un container in ascolto sulla porta TCP 8080.

Per impostazione predefinita, il container hello-app rimane in ascolto sulla porta TCP 8080. Puoi vedere il file Dockerfile e il codice sorgente dell'app.

Sostituisci [SERVICE_IP_ADDRESS] con un indirizzo di tua proprietà non ancora in uso. Ad esempio, potresti impostare un indirizzo IP pubblico di proprietà dell'azienda. In alternativa, puoi impostare un indirizzo privato nella rete aziendale.

L'indirizzo che scegli deve essere instradabile dalla località di qualsiasi client che invia richieste al servizio. Ad esempio, se scegli un indirizzo privato, i client esterni non saranno in grado di inviare richieste al servizio.

Salva il manifest in un file denominato my-service.yaml e crea il Service:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] apply -f my-service.yaml

dove [USER_CLUSTER_KUBECONFIG] è il percorso del tuo file kubeconfig del cluster utente.

Quando crei il servizio, i cluster Anthos su VMware configurano automaticamente l'indirizzo loadBalancerIP sul bilanciatore del carico BIG-IP di F5.

Visualizza il tuo servizio:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] get service my-service --output yaml

L'output è simile al seguente:

apiVersion: v1
kind: Service
metadata:
  ...
  name: my-service
  namespace: default
  ...
spec:
  clusterIP: 10.107.84.202
  externalTrafficPolicy: Cluster
  loadBalancerIP: 203.0.113.1
  ports:
  - nodePort: 31919
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: metrics
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.1

Nell'output precedente puoi vedere che il tuo servizio ha un clusterIP e un loadBalancerIP. Ha anche un nodePort, un port e un targetPort.

clusterIP non è pertinente a questo esercizio. loadBalancerIP è l'indirizzo IP che hai fornito in my-service.yaml.

Prendiamo ad esempio i valori mostrati nell'output precedente. In altre parole, supponiamo che il tuo servizio abbia loadBalancerIP = 203.0.113.1, port = 80, nodePort = 31919 e targetPort = 8080.

Un client invia una richiesta a 203.0.113.1 sulla porta TCP 80. La richiesta viene instradata al bilanciatore del carico BIG-IP di F5. Il bilanciatore del carico sceglie uno dei nodi del cluster utente e inoltra la richiesta a [NODE_ADDRESS] sulla porta TCP 31919. Le regole iptables sul nodo inoltrano la richiesta a un pod membro sulla porta TCP 8080.

Chiama il servizio:

curl [SERVICE_IP_ADDRESS]

dove [SERVICE_IP_ADDRESS] è l'indirizzo da te specificato per loadBalancerIP.

L'output mostra un messaggio Hello, world!:

curl 21.0.133.48
Hello, world!
Version: 2.0.0
Hostname: my-deployment-dbd86c8c4-9wpbv

Eliminazione del servizio

Elimina il servizio:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] delete service my-service

Verifica che il servizio sia stato eliminato:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] get services

L'output non mostra più my-service.

Eliminazione del deployment

Elimina il deployment:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] delete deployment my-deployment

Verifica che il deployment sia stato eliminato:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] get deployments

L'output non mostra più my-deployment.

Passaggi successivi

Attivazione del traffico in entrata