Prerequisiti Crea un namespace Crea una distribuzione Kubernetes Creazione di un servizio Rivedi le risorse create Esegui una shell su un Pod Fasi successive

Aiutaci 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à.

Vuoi contribuire a questa guida per l'utente? Scorri fino alla fine di questa pagina e seleziona Modifica questa pagina su GitHub. I tuoi contributi contribuiranno a rendere la nostra guida utente migliore per tutti.

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

Implementa un'applicazione di esempio su Linux

In questo argomento, distribuirai un'applicazione di esempio nel tuo cluster su nodi Linux.

Prerequisiti

Un esistente Kubernetes cluster con almeno un nodo. Se non disponi di un EKS cluster Amazon esistente, puoi implementarne uno utilizzando una delle guide incluse. Inizia a usare Amazon EKS
Kubectl installato sul computer. Per ulteriori informazioni, consulta Configura kubectl ed eksctl.
Kubectl configurato per comunicare con il cluster. Per ulteriori informazioni, consulta Connect kubectl a un EKS cluster creando un file kubeconfig.
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 creato un cluster con una delle guide inseriteInizia a usare Amazon EKS, dovrai creare un nuovo profilo o aggiungere lo spazio dei nomi al tuo profilo esistente, perché il profilo creato nelle guide introduttive non specifica lo spazio dei nomi utilizzato in questo tutorial. VPCÈ inoltre necessario 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. Una volta che avrai una migliore comprensione di Kubernetes Pods, implementazioni e servizi, puoi sperimentare la modifica di altri valori.

Crea un namespace

Un namespace consente di raggruppare le risorse in Kubernetes. Per ulteriori informazioni, vedete Namespace in Kubernetes documentazione. Se avete intenzione di implementare la vostra applicazione di esempio per semplificare la gestione del calcolo con AWS Fargate, assicuratevi che il valore contenuto namespace nel vostro Define quali Pod utilizzare AWS Fargate al momento del lancio sia. eks-sample-app


kubectl create namespace eks-sample-app

Crea una distribuzione Kubernetes

Crea un Kubernetes distribuzione. Questa implementazione di esempio estrae un'immagine del contenitore da un archivio pubblico e distribuisce tre repliche (singole). Pods) di esso nel tuo cluster. Per ulteriori informazioni, consulta Implementazioni nella Kubernetes documentazione.

Salva i contenuti seguenti in un file denominato eks-sample-deployment.yaml. I contenitori dell'applicazione di esempio non utilizzano lo storage di rete, ma potresti avere applicazioni che lo richiedono. Per ulteriori informazioni, consulta Archivia i dati delle applicazioni per il tuo cluster.
- 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. Puoi determinare l'architettura hardware su cui è supportata l'immagine visualizzando i dettagli dell'immagine nel repository da cui l'hai estratta. Quando distribuisci immagini che non supportano un tipo di architettura hardware o in cui non desideri che l'immagine venga distribuita, rimuovi quel tipo dal manifesto. Per ulteriori informazioni, consulta Etichette, annotazioni e sfumature note nel Kubernetes documentazione.
- kubernetes.io/os: linuxnodeSelectorSignifica che se lo avessi Linux e Windows nodi (ad esempio) del cluster, l'immagine verrebbe distribuita solo su Linux nodi. Per ulteriori informazioni, vedere Etichette, annotazioni e sfumature ben note nel Kubernetes documentazione.
```
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
```
Applicare il manifesto di implementazione al cluster.
```
kubectl apply -f eks-sample-deployment.yaml
```

Creazione di un servizio

Un servizio consente di accedere a tutte le repliche tramite un unico indirizzo IP o nome. Per ulteriori informazioni, vedere Service in Kubernetes documentazione. Sebbene non sia implementato nell'applicazione di esempio, se disponi di applicazioni che devono interagire con altri AWS servizi, ti consigliamo di creare Kubernetes account di servizio per i tuoi Podse associarli agli AWS IAM account. Specificando gli account di servizio, il Pods dispongono solo delle autorizzazioni minime specificate per consentire loro di interagire con altri servizi. Per ulteriori informazioni, consulta Ruoli IAM per gli account di servizio.

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 per bilanciare il carico dell'applicazione o del traffico di rete 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
```
Applicare il manifesto del servizio al cluster.
```
kubectl apply -f eks-sample-service.yaml
```

Rivedi le risorse create

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     <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. Ne vedi anche tre Pods. Questo perché 3 replicas sono stati specificati nel manifesto di esempio. Per ulteriori informazioni sull' Pods, vedete Pods in Kubernetes documentazione. Kubernetes crea automaticamente la replicaset risorsa, anche se non è specificata nei manifesti di esempio. Per ulteriori informazioni suReplicaSets, vedere ReplicaSetin Kubernetes documentazione.

Nota
Kubernetes mantiene il numero di repliche specificate nel manifesto. Se questa fosse una distribuzione di produzione e tu volessi Kubernetes per scalare orizzontalmente il numero di repliche o scalare verticalmente le risorse di elaborazione per Pods, a tale scopo, utilizzate le distribuzioni del pod Scale con Horizontal Pod Autoscaler e le risorse del pod Adjust con Vertical Pod Autoscaler.

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:       <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 di IP: è un indirizzo IP univoco raggiungibile da qualsiasi nodo o Pod all'interno del cluster, ma non può essere raggiunto dall'esterno del cluster. I valori per Endpoints sono gli indirizzi IP assegnati dall'interno dell'utente VPC al Pods che fanno parte del servizio.

Visualizza i dettagli di uno dei Pods elencato nell'output quando hai visualizzato il namespace in un passaggio precedente. Sostituisci 776d8f8fd8-78w66 con il valore restituito per uno dei tuoi Pods.
```
kubectl -n eks-sample-app describe pod eks-sample-linux-deployment-65b7669776-m6qxz
```
Esempio di output 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 di IP: è un IP univoco assegnato a Pod dal CIDR blocco assegnato alla sottorete in cui si trova il nodo. Se preferisci assegnare Pods Indirizzi IP di CIDR blocchi diversi, puoi modificare il comportamento predefinito. Per ulteriori informazioni, consulta Implementazione pods in sottoreti alternative con rete personalizzata. Puoi anche vedere che il Kubernetes lo scheduler ha pianificato il Pod sul Node con l'indirizzo 192.168.45.132 IP.

Suggerimento
Invece di utilizzare la riga di comando, è possibile visualizzare molti dettagli su Pods, servizi, implementazioni e altro Kubernetes risorse in. AWS Management Console Per ulteriori informazioni, consulta Visualizza le risorse Kubernetes nel AWS Management Console.

Esegui una shell su un Pod

Esegui una shell su Pod che hai descritto nel passaggio precedente, sostituendolo 65b7669776-m6qxz con l'ID di uno dei tuoi Pods.
```
kubectl exec -it eks-sample-linux-deployment-65b7669776-m6qxz -n eks-sample-app -- /bin/bash
```
Dal Pod shell, visualizza l'output del server Web installato con la distribuzione in un passaggio precedente. È necessario specificare solo il nome del servizio. Viene risolto nell'indirizzo IP del servizio da CoreDNS, che viene distribuito con un EKS cluster Amazon, per impostazione predefinita.
```
curl eks-sample-linux-service
```
Di seguito viene riportato un output di esempio:
```
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
[...]
```
Dal Pod shell, visualizza il DNS server 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 Pods distribuito nel cluster.
Disconnettersi da Pod exitdigitando.
Una volta che hai finito con l'applicazione di esempio, puoi rimuovere lo spazio dei nomi, il servizio e la distribuzione 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:

📝 Modifica questa pagina su GitHub

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

Esempio di distribuzione di applicazioni (Windows)