Implementare un'applicazione di esempio

In questa sezione, imparerai a implementare un'applicazione di esempio sul cluster.

Prerequisiti

Un cluster Kubernetes esistente cluster con almeno un nodo. Se non si dispone di un cluster Amazon EKS esistente, è possibile implementarne uno utilizzando una delle guide su Guida introduttiva ad Amazon EKS. Se stai eseguendo l'implementazione di un'applicazione Windows, allora il supporto Windows deve essere abilitato per il cluster e almeno un nodo Windowsdi Amazon EC2.
Kubectl installato sul computer. Per ulteriori informazioni, consulta Installazione o aggiornamento di kubectl.
Kubectl configurato per comunicare con il cluster. Per ulteriori informazioni, consulta Creazione o aggiornamento di un file kubeconfig per un cluster Amazon EKS.
Se si prevede di implementare il carico di lavoro di esempio in Fargate, è necessario disporre di un profilo Fargate che include lo stesso spazio dei nomi creato in questo tutorial, che è eks-sample-app, a meno che non cambi il nome. Se hai usato una delle guide alle operazioni di base per creare il cluster, dovrai creare un nuovo profilo o aggiungere lo spazio dei nomi al profilo esistente, poiché il profilo creato nelle guide introduttive non specifica lo spazio dei nomi utilizzato in questo tutorial. Il VPC deve disporre di almeno una sottorete privata.

Per implementare un'applicazione di esempio

Sebbene molte variabili siano modificabili nei passaggi seguenti, si consiglia di modificare solo i valori delle variabili, se specificato. Con una migliore conoscenza dei Pods, delle implementazioni e dei servizi Kubernetes, puoi provare a modificare altri valori.

Crea uno spazio dei nomi . Uno spazio dei nomi consente di raggruppare le risorse in Kubernetes. Per ulteriori informazioni, consulta Spazi dei nomi nella documentazione di Kubernetes. Se si prevede di implementare l'applicazione di esempio su AWS Fargate, assicurati che il valore per namespace nel AWS Fargate profilo sia eks-sample-app.
```
kubectl create namespace eks-sample-app
```

Crea una implementazione Kubernetes. Questa implementazione di esempio estrae un'immagine container da un repository pubblico e ne implementa tre repliche (singoli Pods) sul cluster. Per ulteriori informazioni, consulta Implementazioni nella documentazione di Kubernetes. Puoi implementare l'applicazione su nodi Linux o Windows. Se stai eseguendo l'implementazione su Fargate, potrai implementare solo un'applicazione Linux.

Salva i seguenti contenuti in un file denominato eks-sample-deployment.yaml. I container nell'applicazione di esempio non utilizzano l'archiviazione di rete, ma potrebbe essere necessaria per determinate applicazioni. Per ulteriori informazioni, consulta Archiviazione.

Linux

amd64 o arm64 values nella chiave kubernetes.io/arch significa che l'applicazione può essere implementata su entrambe le architetture hardware (se entrambe sono presenti nel cluster). Ciò è possibile perché questa immagine è un'immagine multi-architettura, ma non tutte lo sono. È possibile determinare l'architettura hardware su cui è supportata l'immagine visualizzando i dettagli dell'immagine nel repository da cui la stai estraendo. Quando si implementano immagini che non supportano un tipo di architettura hardware o che non si desidera implementare, rimuovere quel tipo ti architettura dal manifesto. Per ulteriori informazioni, consulta Etichette, annotazioni e taint note nella documentazione di Kubernetes.

kubernetes.io/os: linux nodeSelector significa che se avessi nodi Linux e Windows, ad esempio nel cluster, l'immagine verrebbe implementata solo sui nodi Linux. Per ulteriori informazioni, consulta Etichette, annotazioni e taint note nella documentazione di Kubernetes.


apiVersion: apps/v1
kind: Deployment
metadata:
  name: eks-sample-linux-deployment
  namespace: eks-sample-app
  labels:
    app: eks-sample-linux-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: eks-sample-linux-app
  template:
    metadata:
      labels:
        app: eks-sample-linux-app
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
                - arm64
      containers:
      - name: nginx
        image: public.ecr.aws/nginx/nginx:1.23
        ports:
        - name: http
          containerPort: 80
        imagePullPolicy: IfNotPresent
      nodeSelector:
        kubernetes.io/os: linux

Windows

kubernetes.io/os: windows nodeSelector significa che se avessi nodi Windows e Linux, ad esempio nel cluster, l'immagine verrebbe implementata solo sui nodi Windows. Per ulteriori informazioni, consulta Etichette, annotazioni e taint note nella documentazione di Kubernetes.


apiVersion: apps/v1
kind: Deployment
metadata:
  name: eks-sample-windows-deployment
  namespace: eks-sample-app
  labels:
    app: eks-sample-windows-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: eks-sample-windows-app
  template:
    metadata:
      labels:
        app: eks-sample-windows-app
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: beta.kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: windows-server-iis
        image: mcr.microsoft.com/windows/servercore:ltsc2019
        ports:
        - name: http
          containerPort: 80
        imagePullPolicy: IfNotPresent
        command:
        - powershell.exe
        - -command
        - "Add-WindowsFeature Web-Server; Invoke-WebRequest -UseBasicParsing -Uri 'https://dotnetbinaries.blob.core.windows.net/servicemonitor/2.0.1.6/ServiceMonitor.exe' -OutFile 'C:\\ServiceMonitor.exe'; echo '<html><body><br/><br/><marquee><H1>Hello EKS!!!<H1><marquee></body><html>' > C:\\inetpub\\wwwroot\\default.html; C:\\ServiceMonitor.exe 'w3svc'; "
      nodeSelector:
        kubernetes.io/os: windows

Applicare il manifesto di implementazione al cluster.
```
kubectl apply -f eks-sample-deployment.yaml
```

Crea un servizio. Un servizio consente di accedere a tutte le repliche tramite un unico indirizzo IP o nome. Per ulteriori informazioni, consulta Servizi nella documentazione di Kubernetes. Anche se non implementate nell'applicazione di esempio, se hai applicazioni che devono interagire con altri servizi AWS, ti consigliamo di creare gli account di servizio Kubernetes per i tuoi Pods e associarli agli account AWS IAM. Specificando gli account di servizio, i Pods avranno solo le autorizzazioni minime necessarie per interagire con altri servizi. Per ulteriori informazioni, consulta Ruoli IAM per gli account di servizio.
1. Salva il seguente contenuto in un file denominato eks-sample-service.yaml. Kubernetes assegna al servizio il proprio indirizzo IP a cui è possibile accedere solo dall'interno del cluster. Per accedere al servizio dall'esterno del cluster, implementare il AWS Load Balancer Controller per bilanciare il carico dell'applicazione o del traffico di rete verso il servizio.
  Linux
  apiVersion: v1 kind: Service metadata: name: eks-sample-linux-service namespace: eks-sample-app labels: app: eks-sample-linux-app spec: selector: app: eks-sample-linux-app ports: - protocol: TCP port: 80 targetPort: 80
  Windows
  apiVersion: v1 kind: Service metadata: name: eks-sample-windows-service namespace: eks-sample-app labels: app: eks-sample-windows-app spec: selector: app: eks-sample-windows-app ports: - protocol: TCP port: 80 targetPort: 80
2. Applicare il manifesto del servizio al cluster.
```
kubectl apply -f eks-sample-service.yaml
```
Visualizzare tutte le risorse nello spazio dei nomi eks-sample-app.
```
kubectl get all -n eks-sample-app
```
Di seguito viene riportato un output di esempio:

Se hai implementato risorse Windows, allora tutte le istanze di linux nel seguente output saranno windows. Gli altri valori di esempio possono essere diversi dall'output.
```
NAME                                               READY   STATUS    RESTARTS   AGE
pod/eks-sample-linux-deployment-65b7669776-m6qxz   1/1     Running   0          27m
pod/eks-sample-linux-deployment-65b7669776-mmxvd   1/1     Running   0          27m
pod/eks-sample-linux-deployment-65b7669776-qzn22   1/1     Running   0          27m

NAME                               TYPE         CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
service/eks-sample-linux-service   ClusterIP    10.100.74.8     <none>        80/TCP    32m

NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/eks-sample-linux-deployment 3/3     3            3           27m

NAME                                                      DESIRED   CURRENT   READY   AGE
replicaset.apps/eks-sample-linux-deployment-776d8f8fd8    3         3         3       27m
```
Nell'output, è possibile visualizzare il servizio e l'implementazione specificati nel manifesto di esempio implementato nei passaggi precedenti. Saranno visualizzati anche tre Pods. Questo perché 3 replicas sono state specificate nel manifesto di esempio. Per ulteriori informazioni su Pods, consulta Pod nella documentazione di Kubernetes. Kubernetes crea automaticamente la risorsa replicaset, anche se non è specificato nei manifesti di esempio. Per ulteriori informazioni ReplicaSetin meritoReplicaSets, consulta la Kubernetes documentazione.

Nota
Kubernetes mantiene il numero di repliche specificate nel manifesto. Se si tratta di un'implementazione di produzione e si desidera che Kubernetes dimensioni orizzontalmente il numero di repliche e dimensioni verticalmente le risorse di calcolo per i Pods, utilizza Horizontal Pod Autoscaler e Vertical Pod Autoscaler.
Visualizzare i dettagli del servizio implementato. Se hai implementato un servizio Windows, sostituisci linux con windows.
```
kubectl -n eks-sample-app describe service eks-sample-linux-service
```
Di seguito viene riportato un output di esempio:

Se hai implementato risorse Windows, allora tutte le istanze di linux nel seguente output saranno windows. Gli altri valori di esempio possono essere diversi dall'output.
```
Name:              eks-sample-linux-service
Namespace:         eks-sample-app
Labels:            app=eks-sample-linux-app
Annotations:       <none>
Selector:          app=eks-sample-linux-app
Type:              ClusterIP
IP Families:       <none>
IP:                10.100.74.8
IPs:               10.100.74.8
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:         192.168.24.212:80,192.168.50.185:80,192.168.63.93:80
Session Affinity:  None
Events:            <none>
```
Nell'output precedente, il valore per IP: è un indirizzo IP univoco che può essere raggiunto da qualsiasi nodo o Pod all'interno del cluster ma non dall'esterno del cluster. I valori per Endpoints sono indirizzi IP assegnati all'interno del VPC ai Pods che fanno parte del servizio.
Visualizzare i dettagli di uno dei Pods elencati nell'output al momento della visualizzazione dello spazio dei nomi in una fase precedente. Se hai implementato un'app Windows, sostituisci linux con windows e 776d8f8fd8-78w66 con il valore restituito per uno dei tuoi Pods.
```
kubectl -n eks-sample-app describe pod eks-sample-linux-deployment-65b7669776-m6qxz
```
Output abbreviato

Se hai implementato risorse Windows, allora tutte le istanze di linux nel seguente output saranno windows. Gli altri example values possono essere diversi dall'output.
```
Name:         eks-sample-linux-deployment-65b7669776-m6qxz
Namespace:    eks-sample-app
Priority:     0
Node:         ip-192-168-45-132.us-west-2.compute.internal/192.168.45.132
[...]
IP:           192.168.63.93
IPs:
  IP:           192.168.63.93
Controlled By:  ReplicaSet/eks-sample-linux-deployment-65b7669776
[...]
Conditions:
  Type              Status
  Initialized       True
  Ready             True
  ContainersReady   True
  PodScheduled      True
[...]
Events:
  Type    Reason     Age    From                                                 Message
  ----    ------     ----   ----                                                 -------
  Normal  Scheduled  3m20s  default-scheduler                                    Successfully assigned eks-sample-app/eks-sample-linux-deployment-65b7669776-m6qxz to ip-192-168-45-132.us-west-2.compute.internal
[...]
```
Nell'output precedente, il valore per IP: è un IP univoco assegnato al Pod dal blocco CIDR assegnato alla sottorete in cui si trova il nodo. Se preferisci che ai Pods vengano assegnati indirizzi IP da blocchi CIDR diversi, puoi modificare il comportamento di default. Per ulteriori informazioni, consulta Rete personalizzata per i pod. Puoi vedere anche come il pianificatore Kubernetesabbia pianificato il Pod sul Node con l'indirizzo IP 192.168.45.132.

Suggerimento
Anziché utilizzare la riga di comando, puoi visualizzare molti dettagli su Pods, servizi, implementazioni e altre risorse Kubernetes nella AWS Management Console. Per ulteriori informazioni, consulta Visualizzazione delle risorse Kubernetes.

Esegui una shell sul Pod descritto nel passaggio precedente, sostituendo 65b7669776-m6qxz con l'ID di uno dei Pods.

Dalla shell del Pod, visualizza l'output dal server Web installato con l'implementazione in un passaggio precedente. È necessario specificare solo il nome del servizio. Questo viene risolto sull'indirizzo IP del servizio da CoreDNS, implementato con un cluster Amazon EKS, per impostazione predefinita.

Dalla shell del Pod, visualizza il server DNS per il Pod.
Linux
```
cat /etc/resolv.conf
```
Di seguito viene riportato un output di esempio:
```
nameserver 10.100.0.10
search eks-sample-app.svc.cluster.local svc.cluster.local cluster.local us-west-2.compute.internal
options ndots:5
```
Nell'output precedente, 10.100.0.10 viene assegnato automaticamente come nameserver per tutti i Podsimplementati nel cluster.
Windows
```
Get-NetIPConfiguration
```
Output abbreviato
```
InterfaceAlias       : vEthernet
[...]
IPv4Address          : 192.168.63.14
[...]
DNSServer            : 10.100.0.10
```
Nell'output precedente, 10.100.0.10 viene assegnato automaticamente come il server DNS per tutti i Pods implementati nel cluster.
Disconnettersi dal Pod digitando exit.
Una volta terminato l'uso dell'applicazione di esempio, sarà possibile rimuovere lo spazio dei nomi, il servizio e l'implementazione di esempio con il seguente comando.
```
kubectl delete namespace eks-sample-app
```

Fasi successive

Dopo aver distribuito l'applicazione di esempio, potresti provare alcuni dei seguenti esercizi:

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Carichi di lavoro

Vertical Pod Autoscaler

Implementare un'applicazione di esempio

Prerequisiti

Per implementare un'applicazione di esempio

Nota

Suggerimento

Fasi successive