Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Esegui il deployment di un'applicazione

I deployment Kubernetes ti consentono di eseguire workload containerizzati su Google Distributed Cloud, mentre i servizi di tipo LoadBalancer rendono questi workload raggiungibili dall'esterno del tuo cluster. In questo documento, esegui il deployment di un'applicazione di esempio e la esponi su un indirizzo IP esterno dal pool di indirizzi del bilanciatore del carico del cluster.

Prima di iniziare

Per eseguire il deployment di un workload, devi disporre di un cluster utente, ibrido o autonomo in grado di eseguire i workload.

Creazione di un deployment

I passaggi seguenti creano un deployment nel cluster:

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

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"

Utilizza kubectl apply per creare il deployment:
```
kubectl apply -f my-deployment.yaml --kubeconfig CLUSTER_KUBECONFIG
```
Sostituisci CLUSTER_KUBECONFIG con il percorso del file kubeconfig del tuo cluster.

Ottieni informazioni di base sul tuo deployment per confermare che sia stato creato correttamente:

kubectl get deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG

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 tuo deployment:

kubectl get pods --kubeconfig CLUSTER_KUBECONFIG

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

NAME                             READY   STATUS    RESTARTS   AGE
my-deployment-869f65669b-5259x   1/1     Running   0          34s
my-deployment-869f65669b-9xfrs   1/1     Running   0          34s
my-deployment-869f65669b-wn4ft   1/1     Running   0          34s

Ottieni informazioni dettagliate sul tuo deployment:

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

L'output mostra i dettagli della specifica e dello stato del deployment:

apiVersion: apps/v1
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: "2023-06-29T16:17:17Z"
    lastUpdateTime: "2023-06-29T16:17:17Z"
    message: Deployment has minimum availability.
    reason: MinimumReplicasAvailable
    status: "True"
    type: Available
  - lastTransitionTime: "2023-06-29T16:17:12Z"
    lastUpdateTime: "2023-06-29T16:17:17Z"
    message: ReplicaSet "my-deployment-869f65669b" has successfully progressed.
    reason: NewReplicaSetAvailable
    status: "True"
    type: Progressing
  observedGeneration: 1
  readyReplicas: 3
  replicas: 3
  updatedReplicas: 3

Descrivi il deployment:

kubectl describe deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG

L'output mostra i dettagli del deployment formattati correttamente, incluso il ReplicaSet associato:

Name:                   my-deployment
Namespace:              default
CreationTimestamp:      Thu, 29 Jun 2023 16:17:12 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
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:         <none>
    Host Port:    <none>
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   my-deployment-869f65669b (3/3 replicas created)
Events:
  Type    Reason             Age    From                   Message
  ----    ------             ----   ----                   -------
  Normal  ScalingReplicaSet  6m50s  deployment-controller  Scaled up replica set my-deployment-869f65669b to 3

Crea un servizio di tipo `LoadBalancer`

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

Per creare un servizio di tipo LoadBalancer:

Copia il seguente manifest in un file denominato my-service.yaml:
```
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: metrics
    department: sales
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
```
Ecco gli aspetti importanti da comprendere sul servizio in questo esercizio:
- Qualsiasi pod con l'etichetta app: metrics e l'etichetta department: sales è membro del servizio. 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 visualizzare questa impostazione della porta esaminando il Dockerfile e il codice sorgente dell'app.
Utilizza kubectl apply per creare il servizio nel tuo cluster:
```
kubectl apply -f my-service.yaml --kubeconfig CLUSTER_KUBECONFIG
```
Sostituisci CLUSTER_KUBECONFIG con il percorso del file kubeconfig del tuo cluster.
Visualizza il tuo servizio:
```
kubectl get service my-service --output yaml --kubeconfig CLUSTER_KUBECONFIG
```
L'output è simile al seguente:
```
apiVersion: v1
kind: Service
metadata:
  ...
  name: my-service
  namespace: default
  ...
spec:
  allocateLoadBalancerNodePorts: true
  clusterIP: 10.96.2.165
  clusterIPs:
  - 10.96.2.165
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 31565
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: metrics
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 192.168.1.13
```
Nell'output precedente, puoi vedere che il tuo servizio ha un clusterIP e un indirizzo IP esterno. Inoltre, ha un nodePort, un port e un targetPort.

clusterIP non è pertinente per questo esercizio. L'indirizzo IP esterno (status.loadBalancer.ingress.ip) proviene dall'intervallo di indirizzi che hai specificato quando hai definito i pool di indirizzi del bilanciatore del carico (spec.loadBalancer.addressPools) nel file di configurazione del cluster.

Ad esempio, prendi i valori mostrati nell'output precedente per il tuo servizio:
- Indirizzo IP esterno: 192.168.1.13
- port: 80
- nodePort: 31565
- targetPort: 8080
Un client invia una richiesta a 192.168.1.13 sulla porta TCP 80. La richiesta viene instradata al bilanciatore del carico e da lì viene inoltrata a un pod membro sulla porta TCP 8080.
Chiama il servizio:
```
curl INGRESS_IP_ADDRESS
```
Sostituisci INGRESS_IP_ADDRESS con l'indirizzo IP in entrata nella sezione status del servizio che hai recuperato nel passaggio precedente (status.loadBalancer.ingress).

L'output mostra un messaggio Hello, world!:
```
Hello, world!
Version: 2.0.0
Hostname: my-deployment-869f65669b-wn4ft
```

Limiti delle porte LoadBalancer

Il tipo LoadBalancer è un'estensione del tipo NodePort. Quindi un servizio di tipo LoadBalancer ha un indirizzo IP del cluster e uno o più valori nodePort. Per impostazione predefinita, Kubernetes alloca le porte dei nodi ai servizi di tipo LoadBalancer. Queste allocazioni possono esaurire rapidamente le porte dei nodi disponibili tra le 2768 assegnate al tuo cluster. Per risparmiare porte dei nodi, disabilita l'allocazione delle porte dei nodi del bilanciatore del carico impostando il campo allocateLoadBalancerNodePorts su false nella specifica del servizio LoadBalancer. Questa impostazione impedisce a Kubernetes di allocare porte dei nodi ai servizi LoadBalancer. Per saperne di più, consulta Disattivazione dell'allocazione NodePort del bilanciatore del carico nella documentazione di Kubernetes.

Ecco un manifest per creare un servizio che non utilizza porte dei nodi:

apiVersion: v1
kind: Service
metadata:
  name: service-does-not-use-nodeports
spec:
  selector:
    app: my-app
  type: LoadBalancer
  ports:
  - port: 8000
  # Set allocateLoadBalancerNodePorts to false
  allocateLoadBalancerNodePorts: false

Elimina il servizio

Per eliminare il servizio:

Utilizza kubectl delete per eliminare il servizio dal cluster:

kubectl delete service my-service --kubeconfig CLUSTER_KUBECONFIG

Verifica che il servizio sia stato eliminato:
```
kubectl get services --kubeconfig CLUSTER_KUBECONFIG
```
L'output non mostra più my-service.

Elimina il deployment

Per eliminare il deployment:

Utilizza kubectl delete per eliminare il deployment dal cluster:
```
kubectl delete deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG
```
Verifica che il deployment sia stato eliminato:
```
kubectl get deployments --kubeconfig CLUSTER_KUBECONFIG
```
L'output non mostra più my-deployment.

Passaggi successivi

Crea 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.