Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Esegui il deployment di un'applicazione

Questo documento fornisce un esempio di come eseguire il deployment di un'applicazione in un cluster utente creato con Google Distributed Cloud (solo software) per VMware.

Prima di iniziare

Per l'esempio riportato qui, è necessario un cluster utente che utilizzi il bilanciamento del carico MetalLB in bundle. Per istruzioni sulla creazione di un cluster utente minimo che utilizzi MetalLB, consulta Creare cluster di base.

Puoi utilizzare la Google Cloud consoleo lo strumento a riga di comando kubectl su lla workstation di amministrazione per eseguire il deployment dell'applicazione.

Console

Nella console, vai alla pagina Panoramica dei cluster Google Kubernetes Engine.

Vai ai cluster GKE
Nell'elenco dei cluster, fai clic sul cluster utente e verifica di aver eseguito l'accesso al cluster.

Se non hai ancora eseguito l'accesso al cluster utente, segui le istruzioni in Gestire i cluster dalla Google Cloud console.

Container

In Nuovo container, seleziona Immagine container esistente.
In Percorso immagine, inserisci us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0.
Fai clic su Continua.

Configurazione

In Nome deployment, inserisci my-deployment.
In Spazio dei nomi, inserisci default.
Inserisci queste due etichette:
- Chiave 1: app, Valore 1: metrics
- Chiave 2: department, Valore 2 sales
Nel menu a discesa Cluster Kubernetes, seleziona il cluster.
Fai clic su Continua.

Comprometti

Seleziona Esponi il deployment come nuovo servizio.
In Porta 1, inserisci 80.
In Porta di destinazione 1, inserisci 8080. Questo è il valore appropriato perché il container hello-app è in ascolto sulla porta TCP 8080 per impostazione predefinita. Puoi verificare questo esaminando il Dockerfile e il codice sorgente dell'app.
In Protocollo 1, seleziona TCP.
In Tipo di servizio, seleziona LoadBalancer.

Nella parte inferiore della pagina, fai clic sul pulsante Esegui il deployment.

Visualizzare i dettagli del deployment e del servizio

Quando il deployment è pronto, viene aperta la pagina Dettagli deployment nella sezione Workload Kubernetes della Google Cloud console. In questa pagina puoi visualizzare i dettagli del deployment e dei relativi tre pod.
In Servizi di esposizione, fai clic sul nome del servizio che espone il deployment. Per questo esercizio, il nome è my-deployment-service.
Viene visualizzata la pagina Dettagli del servizio. In questa pagina puoi visualizzare i dettagli del servizio. Ad esempio, puoi vedere che qualsiasi pod con le etichette app: metrics e department: sales è membro del servizio. Ricorda che i pod in my-deployment hanno queste etichette.

Puoi anche visualizzare un valore per IP del bilanciatore del carico. L'IP del bilanciatore del carico è stato configurato automaticamente sul bilanciatore del carico del cluster.

Inoltro per il servizio

Supponiamo che un client esterno al cluster invii una richiesta all'IP del bilanciatore del carico sulla porta TCP 80. La richiesta viene instradata al bilanciatore del carico del cluster. Il bilanciatore del carico inoltra la richiesta a un pod membro sulla porta TCP 8080. Ricorda che ogni pod in my-deployment ha un container in ascolto sulla porta TCP 8080.

Testare il servizio

Vai a una macchina in cui l'IP del bilanciatore del carico è instradabile.

Per chiamare il servizio, inserisci l'IP del bilanciatore del carico in un browser o utilizza un comando come curl. Ad esempio:

curl [LOAD_BALANCER_IP]:80

L'output mostra un messaggio Hello, world!. Ad esempio:

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

Eliminare il deployment

Vai alla pagina Workload nella sezione Kubernetes Engine della console.

Vai alla pagina Workload

Nell'elenco dei deployment, seleziona my-deployment.

Nella parte superiore della pagina, fai clic su Elimina. In questo modo vengono eliminati sia il deployment sia il servizio di esposizione.

Riga di comando

Connettersi alla workstation di amministrazione

Ottieni una connessione SSH alla workstation di amministrazione. Esegui i passaggi seguenti sulla workstation di amministrazione.

Creare 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: "us-docker.pkg.dev/google-samples/containers/gke/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 cluster utente.

Recupera le informazioni di base sul 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 nel 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

Recupera informazioni dettagliate sul deployment:

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

L'output mostra i dettagli della specifica e dello 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: us-docker.pkg.dev/google-samples/containers/gke/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 deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG describe deployment my-deployment

L'output mostra i dettagli del deployment in un formato ben strutturato, incluso il ReplicaSet ReplicaSet:

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:        us-docker.pkg.dev/google-samples/containers/gke/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)

Creare un servizio di tipo LoadBalancer

Un modo per esporre il deployment ai client esterni al 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
  ports:
  ‑ port: 80
    targetPort: 8080

Ai fini di questo esercizio, ecco le cose importanti da comprendere sul servizio:

Qualsiasi pod con l'etichetta app: metrics e l'etichetta department: sales è 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 è in ascolto sulla porta TCP 8080. Puoi verificarlo esaminando il Dockerfile e il codice sorgente dell'app.

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

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

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

Quando crei il servizio, Google Distributed Cloud configura automaticamente l'indirizzo loadBalancerIP sul bilanciatore del carico del cluster.

Visualizza il servizio:

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

L'output è simile al seguente:

kind: Service
metadata:
  ...
  name: my-service
  namespace: default
  ...
spec:
  allocateLoadBalancerNodePorts: true
  clusterIP: 10.96.1.39
  clusterIPs:
  - 10.96.1.39
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 31184
    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 servizio ha un clusterIP e un loadBalancerIP. Ha anche una port e una targetPort.

clusterIP non è pertinente a questo esercizio. loadBalancerIP è l'indirizzo IP che i client esterni al cluster possono utilizzare per chiamare il servizio.

Ad esempio, prendi i valori mostrati nell'output precedente. Supponiamo che il servizio abbia loadBalancerIP = 203.0.113.1, port = 80 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 del cluster. Il bilanciatore del carico inoltra la richiesta a un pod membro sulla porta TCP 8080.

Chiama il servizio:

curl LOAD_BALANCER_IP

L'output mostra un messaggio Hello, world!:

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

Eliminare il 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.

Eliminare il 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

Creazione di un Servizio e un Ingress

Esegui il deployment di un'applicazione Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.