Prerequisiti Creare uno spazio dei nomi Creazione di un’implementazione Kubernetes Crea un servizio.Esame delle risorse create Eseguire una shell su un pod Fasi successive

Implementazione di un’applicazione esemplificativa su Windows

In questa sezione, imparerai a implementare un’applicazione esemplificativa nel cluster sui nodi Windows.

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. Devi avere il Supporto Windows abilitato per il cluster e almeno un nodo Windows di Amazon EC2.
Kubectl installato sul computer. Per ulteriori informazioni, consulta Impostazione di kubectl e eksctl.
Kubectl configurato per comunicare con il cluster. Per ulteriori informazioni, consulta Connettere kubectl a un cluster EKS 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 in Nozioni di base su Amazon EKS, 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 nella documentazione Kubernetes. Se intendi di implementare la tua applicazione esemplificativa per semplificare la gestione del calcolo con AWS Fargate, assicurati che il valore per namespace nel tuo Definisci quali pod utilizzano AWS Fargate al momento di un avvio sia eks-sample-app.


kubectl create namespace eks-sample-app

Creazione di 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 nella documentazione Kubernetes.

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.

kubernetes.io/os: windows nodeSelector significa che se avessi nodi Windows e Linux, ad esempio nel cluster, l'immagine verrebbe implementata solo nei nodi Windows. Per ulteriori informazioni, consulta Etichette, annotazioni e taint note nella documentazione 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: 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, consultare la sezione Servizio 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.

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-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
```
Applicare il manifesto del servizio al cluster.
```
kubectl apply -f eks-sample-service.yaml
```

Esame delle 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-windows-deployment-65b7669776-m6qxz   1/1     Running   0          27m
pod/eks-sample-windows-deployment-65b7669776-mmxvd   1/1     Running   0          27m
pod/eks-sample-windows-deployment-65b7669776-qzn22   1/1     Running   0          27m

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

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

NAME                                                      DESIRED   CURRENT   READY   AGE
replicaset.apps/eks-sample-windows-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 nella documentazione Kubernetes. Kubernetes crea automaticamente la risorsa replicaset, anche se non è specificato nei manifesti esemplificativi. Per ulteriori informazioni su ReplicaSets, consultare 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 e Adjust pod resources with Vertical Pod Autoscaler per fare ciò.

Visualizzare i dettagli del servizio implementato.


kubectl -n eks-sample-app describe service eks-sample-windows-service

Di seguito viene riportato un output di esempio:


Name:              eks-sample-windows-service
Namespace:         eks-sample-app
Labels:            app=eks-sample-windows-app
Annotations:       <none>
Selector:          app=eks-sample-windows-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 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.

Visualizza i dettagli di uno dei pod elencati nell'output al momento della visualizzazione dello spazio dei nomi in un passaggio precedente. Sostituisci 776d8f8fd8-78w66 con il valore restituito per uno dei pod.
```
kubectl -n eks-sample-app describe pod eks-sample-windows-deployment-65b7669776-m6qxz
```
Output esemplificativo abbreviato
```
Name:         eks-sample-windows-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-windows-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-windows-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. È 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 Visualizzazione delle risorse Kubernetes in Console di gestione AWS.

Eseguire una shell su un pod

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-windows-deployment-65b7669776-m6qxz -n eks-sample-app -- powershell.exe
```
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.
```
Invoke-WebRequest -uri eks-sample-windows-service/default.html -UseBasicParsing
```
Di seguito viene riportato un output di esempio:
```
StatusCode        : 200
StatusDescription : OK
Content           : < h t m l > < b o d y > < b r / > < b r / > < m a r q u e e > < H 1 > H e l l o
                      E K S ! ! ! < H 1 > < m a r q u e e > < / b o d y > < h t m l >
```
Dalla shell del pod, visualizza il server DNS per il pod.
```
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 pod implementati nel cluster.
Disconnettersi dal pod digitando exit.
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:

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

Implementazione esemplificativa (Linux)

Vertical Pod Autoscaler