**Contribuisci a migliorare questa pagina**
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Implementazione di un’applicazione esemplificativa
In questa sezione, imparerai a implementare un’applicazione esemplificativa nel cluster sui nodi Linux.
## Prerequisiti
+ Un cluster Kubernetes esistente con almeno un nodo. Se non si dispone di un cluster Amazon EKS esistente, è possibile implementarne uno utilizzando una delle guide in [Nozioni di base su Amazon EKS](getting-started.md).
+ `Kubectl` installato sul computer. Per ulteriori informazioni, consulta [Impostazione di `kubectl` e `eksctl`](install-kubectl.md).
+ `Kubectl` configurato per comunicare con il cluster. Per ulteriori informazioni, consulta [Connettere kubectl a un cluster EKS creando un file kubeconfig](create-kubeconfig.md).
+ Se si prevede di implementare il carico di lavoro di esempio in Fargate, è necessario disporre di un [profilo Fargate](fargate-profile.md) che include lo stesso spazio dei nomi creato in questo tutorial, che è `eks-sample-app`, a meno che non cambi il nome. Se hai creato un cluster con una delle guide in [Nozioni di base su Amazon EKS](getting-started.md), dovrai creare un nuovo profilo o aggiungere il namespace al profilo esistente, poiché il profilo creato nelle guide introduttive non specifica il namespace utilizzato in questo tutorial. Il VPC deve disporre di almeno una sottorete privata.
Sebbene molte variabili siano modificabili nei passaggi seguenti, si consiglia di modificare solo i valori delle variabili, se specificato. Con una migliore conoscenza dei pod, delle implementazioni e dei servizi Kubernetes, è possibile provare a modificare altri valori.
## Creare uno spazio dei nomi
Uno spazio dei nomi consente di raggruppare le risorse in Kubernetes. Per ulteriori informazioni, consultare [Spazio dei nomi](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) nella documentazione Kubernetes. Se intendi di implementare la tua applicazione esemplificativa per [semplificare la gestione del calcolo con AWS Fargate](fargate.md), assicurati che il valore per `namespace` nel tuo [Definisci quali pod utilizzano AWS Fargate al momento di un avvio](fargate-profile.md) sia `eks-sample-app`.
```
kubectl create namespace eks-sample-app
```
## Creazione di un’implementazione Kubernetes
Creare un'implementazione Kubernetes. Questa implementazione esemplificativa estrae un’immagine container da un repository pubblico e ne implementa tre repliche (pod individuali) sul cluster. Per ulteriori informazioni, consultare la sezione [Implementazioni](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) nella documentazione Kubernetes.
1. Salva i contenuti seguenti in un file denominato `eks-sample-deployment.yaml`. I container nell’applicazione esemplificativa non utilizzano l’archiviazione di rete, ma potrebbe essere necessaria per determinate applicazioni. Per ulteriori informazioni, consulta [Utilizzo dell’archiviazione di dati delle applicazioni per il tuo cluster](storage.md).
+ `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](https://gallery.ecr.aws/nginx/nginx) 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](https://kubernetes.io/docs/reference/labels-annotations-taints/) nella documentazione 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](https://kubernetes.io/docs/reference/labels-annotations-taints/) nella documentazione 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
```
1. 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, consultare la sezione [Servizio](https://kubernetes.io/docs/concepts/services-networking/service/) nella documentazione Kubernetes. Anche se non implementato nell’applicazione esemplificativa, se si dispone di applicazioni che devono interagire con altri servizi AWS, ti consigliamo di creare account di servizio Kubernetes per i tuoi pod e di associarli agli account IAM AWS. Specificando gli account di servizio, è possibile che i pod dispongano delle autorizzazioni minime necessarie per interagire con altri servizi. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md).
1. Salva i contenuti seguenti in un file denominato `eks-sample-service.yaml`. Kubernetes assegna al servizio il proprio indirizzo IP accessibile solo dall'interno del cluster. Per accedere al servizio dall'esterno del cluster, implementare il [controller del load balancer AWS](aws-load-balancer-controller.md) per bilanciare il carico dell'[applicazione](alb-ingress.md) o del traffico di [rete](network-load-balancing.md) verso il servizio.
```
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
```
1. Applicare il manifesto del servizio al cluster.
```
kubectl apply -f eks-sample-service.yaml
```
## Esame delle risorse create
1. 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:
```
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 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. Verranno mostrati anche tre pod. Questo perché `3` `replicas` sono state specificate nel manifesto di esempio. Per ulteriori informazioni sui pod, consulta [Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod/) nella documentazione Kubernetes. Kubernetes crea automaticamente la risorsa `replicaset`, anche se non è specificato nei manifesti esemplificativi. Per ulteriori informazioni su `ReplicaSets`, consultare [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/) nella documentazione Kubernetes.
**Nota**
Kubernetes mantiene il numero di repliche specificate nel manifesto. Se si tratta di un’implementazione di produzione e si desidera che Kubernetes scali orizzontalmente il numero di repliche e scali verticalmente le risorse di calcolo per i pod, utilizza [Scale pod deployments with Horizontal Pod Autoscaler](horizontal-pod-autoscaler.md) e [Adjust pod resources with Vertical Pod Autoscaler](vertical-pod-autoscaler.md) per fare ciò.
1. Visualizzare i dettagli del servizio implementato.
```
kubectl -n eks-sample-app describe service eks-sample-linux-service
```
Di seguito viene riportato un output di esempio:
```
Name: eks-sample-linux-service
Namespace: eks-sample-app
Labels: app=eks-sample-linux-app
Annotations:
Selector: app=eks-sample-linux-app
Type: ClusterIP
IP Families:
IP: 10.100.74.8
IPs: 10.100.74.8
Port: 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:
```
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 può essere raggiunto dall’esterno del cluster. I valori per `Endpoints` sono indirizzi IP assegnati all’interno del VPC ai pod che fanno parte del servizio.
1. Visualizza i dettagli di uno dei pod elencati nell'output al momento della [visualizzazione dello spazio dei nomi](#sample-app-view-namespace) in un passaggio precedente. Sostituisci *776d8f8fd8-78w66* con il valore restituito per uno dei pod.
```
kubectl -n eks-sample-app describe pod eks-sample-linux-deployment-65b7669776-m6qxz
```
Output esemplificativo abbreviato
```
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 dall’intervallo CIDR assegnato alla sottorete in cui si trova il nodo. Se si preferisce che ai pod vengano assegnati indirizzi IP da blocchi CIDR diversi, è possibile modificare il comportamento di default. Per ulteriori informazioni, consulta [Implementazione dei pod in sottoreti alternative con reti personalizzate](cni-custom-network.md). È anche possibile vedere come il pianificatore Kubernetes abbia pianificato il pod sul `Node` con l’indirizzo IP *192.168.45.132*.
**Suggerimento**
Anziché utilizzare la riga di comando, è possibile visualizzare molti dettagli su pod, servizi, implementazioni e altre risorse Kubernetes nella Console di gestione AWS. Per ulteriori informazioni, consulta [Visualizza le risorse Kubernetes nel Console di gestione AWS](view-kubernetes-resources.md).
## Eseguire una shell su un pod
1. Esegui una shell sul pod descritto nel passaggio precedente, sostituendo *65 b 7669776-m6qxz* con l'ID di uno dei tuoi pod.
```
kubectl exec -it eks-sample-linux-deployment-65b7669776-m6qxz -n eks-sample-app -- /bin/bash
```
1. Dalla shell del pod, visualizzare l’output dal server Web installato con l’implementazione in una fase precedente. È necessario specificare solo il nome del servizio. Ciò è risolto sull’indirizzo IP del servizio da CoreDNS, implementato con un cluster Amazon EKS, per impostazione predefinita.
```
curl eks-sample-linux-service
```
Di seguito viene riportato un output di esempio:
```
Welcome to nginx!
[...]
```
1. Dalla shell del pod, visualizza il server DNS per il pod.
```
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 pod implementati nel cluster.
1. Disconnettersi dal pod digitando `exit`.
1. Una volta terminato l’uso dell’applicazione esemplificativa, sarà possibile rimuovere il namespace, il servizio e l’implementazione esemplificativa con il seguente comando.
```
kubectl delete namespace eks-sample-app
```
## Fasi successive
Dopo aver implementato l’applicazione esemplificativa, potresti provare a svolgere alcune delle seguenti esercitazioni:
+ [Esegui il routing del traffico di applicazioni e HTTP con Application Load Balancer](alb-ingress.md)
+ [Esegui il routing del traffico TCP e UDP con Network Load Balancer](network-load-balancing.md)