.dkr.ecr.us-east-1.amazonaws.com/test_ecr_repository@sha256:52db9000073d93b9bdee6a7246a68c35a741aaade05a8f4febba0bf795cdac02",
"public.ecr.aws/amazonlinux/amazonlinux@sha256:f972d24199508c52de7ad37a298bda35d8a1bd7df158149b381c03f6c6e363b5"
],
"Parent": "",
"Comment": "",
"Created": "2023-02-23T06:20:11.575053226Z",
"Container": "ec7f2fc7d2b6a382384061247ef603e7d647d65f5cd4fa397a3ccbba9278367c",
"ContainerConfig": {
"Hostname": "ec7f2fc7d2b6",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
],
"Cmd": [
"/bin/sh",
"-c",
"#(nop) ",
"CMD [\"/bin/bash\"]"
],
"Image": "sha256:c1bced1b5a65681e1e0e52d0a6ad17aaf76606149492ca0bf519a466ecb21e51",
"Volumes": null,
"WorkingDir": "",
"Entrypoint": null,
"OnBuild": null,
"Labels": {}
},
"DockerVersion": "20.10.17",
"Author": "",
"Config": {
"Hostname": "",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
],
"Cmd": [
"/bin/bash"
],
"Image": "sha256:c1bced1b5a65681e1e0e52d0a6ad17aaf76606149492ca0bf519a466ecb21e51",
"Volumes": null,
"WorkingDir": "",
"Entrypoint": null,
"OnBuild": null,
"Labels": null
},
"Architecture": "amd64",
"Os": "linux",
"Size": 167436755,
"VirtualSize": 167436755,
"GraphDriver": {
"Data": {
"MergedDir": "/var/lib/docker/overlay2/c2c2351a82b26cbdf7782507500e5adb5c2b3a2875bdbba79788a4b27cd6a913/merged",
"UpperDir": "/var/lib/docker/overlay2/c2c2351a82b26cbdf7782507500e5adb5c2b3a2875bdbba79788a4b27cd6a913/diff",
"WorkDir": "/var/lib/docker/overlay2/c2c2351a82b26cbdf7782507500e5adb5c2b3a2875bdbba79788a4b27cd6a913/work"
},
"Name": "overlay2"
},
"RootFS": {
"Type": "layers",
"Layers": [
"sha256:d5655967c2c4e8d68f8ec7cf753218938669e6c16ac1324303c073c736a2e2a2"
]
},
"Metadata": {
"LastTagTime": "2023-03-02T10:28:47.142155987Z"
}
}
]
```
# Installa SSM Agent sui nodi di lavoro Amazon EKS utilizzando Kubernetes DaemonSet
*Mahendra Revanasiddappa, Amazon Web Services*
## Riepilogo
**Nota, settembre 2021:** l'ultima versione ottimizzata di Amazon EKS AMIs installa automaticamente SSM Agent. Per ulteriori informazioni, consulta le [note di rilascio](https://github.com/awslabs/amazon-eks-ami/releases/tag/v20210621) di giugno 2021 AMIs.
In Amazon Elastic Kubernetes Service (Amazon EKS), a causa delle linee guida sulla sicurezza, ai nodi di lavoro non sono associate coppie di chiavi Secure Shell (SSH). Questo modello mostra come utilizzare il tipo di DaemonSet risorsa Kubernetes per installare AWS Systems Manager Agent (SSM Agent) su tutti i nodi di lavoro, anziché installarlo manualmente o sostituire l'Amazon Machine Image (AMI) per i nodi. DaemonSet utilizza un cron job sul nodo di lavoro per pianificare l'installazione di SSM Agent. È inoltre possibile utilizzare questo modello per installare altri pacchetti sui nodi di lavoro.
Quando si risolvono i problemi del cluster, l'installazione di SSM Agent on demand consente di stabilire una sessione SSH con il nodo di lavoro, di raccogliere i log o di esaminare la configurazione dell'istanza, senza coppie di chiavi SSH.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un cluster Amazon EKS esistente con nodi di lavoro Amazon Elastic Compute Cloud (Amazon EC2).
+ Le istanze di container devono disporre delle autorizzazioni necessarie per comunicare con il servizio SSM. Il ruolo gestito di AWS Identity and Access Management (IAM) **Amazon SSMManaged InstanceCore** fornisce le autorizzazioni necessarie per l'esecuzione di SSM Agent sulle EC2 istanze. Per ulteriori informazioni, consulta la [documentazione di AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-instance-profile.html).
**Limitazioni**
+ Questo modello non è applicabile ad AWS Fargate, perché DaemonSets non sono supportati sulla piattaforma Fargate.
+ Questo modello si applica solo ai nodi di lavoro basati su Linux.
+ I DaemonSet pod funzionano in modalità privilegiata. Se il cluster Amazon EKS dispone di un webhook che blocca i pod in modalità privilegiata, l'agente SSM non verrà installato.
## Architecture
Il diagramma seguente illustra l'architettura di questo modello.
![\[Utilizzo di Kubernetes DaemonSet per installare SSM Agent sui nodi di lavoro Amazon EKS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/016d53f3-45c1-4913-b542-67124e1462b8/images/3a6dfd00-e54b-44d5-843a-4c26ce9826c9.png)
## Tools (Strumenti)
**Strumenti**
+ [kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) è un'utilità da riga di comando utilizzata per interagire con un cluster Amazon EKS. Questo modello viene utilizzato `kubectl` per distribuire un agente SSM DaemonSet sul cluster Amazon EKS, che installerà l'agente SSM su tutti i nodi di lavoro.
+ [Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) semplifica l'esecuzione di Kubernetes su AWS senza dover installare, utilizzare e mantenere il tuo piano di controllo o i tuoi nodi Kubernetes. Kubernetes è un sistema open source per automatizzare l'implementazione, il dimensionamento e la gestione di applicazioni containerizzate.
+ [AWS Systems Manager Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html) consente di gestire le EC2 istanze, le istanze locali e le macchine virtuali (VMs) tramite una shell interattiva basata su browser con un solo clic o tramite l'AWS Command Line Interface (AWS CLI).
**Codice**
Utilizza il codice seguente per creare un file di DaemonSet configurazione che installerà l'agente SSM sul cluster Amazon EKS. Segui le istruzioni nella sezione [Epics](#install-ssm-agent-on-amazon-eks-worker-nodes-by-using-kubernetes-daemonset-epics).
```
cat << EOF > ssm_daemonset.yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
labels:
k8s-app: ssm-installer
name: ssm-installer
namespace: kube-system
spec:
selector:
matchLabels:
k8s-app: ssm-installer
template:
metadata:
labels:
k8s-app: ssm-installer
spec:
containers:
- name: sleeper
image: busybox
command: ['sh', '-c', 'echo I keep things running! && sleep 3600']
initContainers:
- image: amazonlinux
imagePullPolicy: Always
name: ssm
command: ["/bin/bash"]
args: ["-c","echo '* * * * * root yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm & rm -rf /etc/cron.d/ssmstart' > /etc/cron.d/ssmstart"]
securityContext:
allowPrivilegeEscalation: true
volumeMounts:
- mountPath: /etc/cron.d
name: cronfile
terminationMessagePath: /dev/termination-log
terminationMessagePolicy: File
volumes:
- name: cronfile
hostPath:
path: /etc/cron.d
type: Directory
dnsPolicy: ClusterFirst
restartPolicy: Always
schedulerName: default-scheduler
terminationGracePeriodSeconds: 30
EOF
```
## Epiche
### Configura kubectl
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Installa e configura kubectl per accedere al cluster EKS. | Se `kubectl` non è già installato e configurato per accedere al cluster Amazon EKS, consulta [Installazione di kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) nella documentazione di Amazon EKS. | DevOps |
### Implementa il DaemonSet
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea il file DaemonSet di configurazione. | Utilizza il codice nella sezione [Codice](#install-ssm-agent-on-amazon-eks-worker-nodes-by-using-kubernetes-daemonset-tools) precedente di questo modello per creare un file di DaemonSet configurazione chiamato`ssm_daemonset.yaml`, che verrà distribuito nel cluster Amazon EKS. Il pod lanciato da DaemonSet ha un contenitore principale e un `init` contenitore. Il contenitore principale ha un `sleep` comando. Il `init` contenitore include una `command` sezione che crea un file cron job per installare SSM Agent sul percorso. `/etc/cron.d/` Il cron job viene eseguito solo una volta e il file che crea viene automaticamente eliminato dopo il completamento del lavoro. Quando il contenitore init è terminato, il contenitore principale attende 60 minuti prima di uscire. Dopo 60 minuti, viene lanciato un nuovo pod. Questo pod installa SSM Agent, se manca, o aggiorna SSM Agent alla versione più recente.Se necessario, puoi modificare il `sleep` comando per riavviare il pod una volta al giorno o per eseguirlo più spesso. | DevOps |
| Implementa il DaemonSet file sul cluster Amazon EKS. | Per distribuire il file di DaemonSet configurazione creato nel passaggio precedente sul cluster Amazon EKS, utilizza il seguente comando:kubectl apply -f ssm_daemonset.yaml
Questo comando crea un comando DaemonSet per eseguire i pod sui nodi di lavoro per installare SSM Agent. | DevOps |
## Risorse correlate
+ [Installazione di kubectl (documentazione Amazon EKS)](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
+ [Configurazione di Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-getting-started.html) (documentazione di AWS Systems Manager)
# Installa l'agente SSM e l' CloudWatch agente sui nodi di lavoro Amazon EKS utilizzando preBootstrapCommands
*Akkamahadevi Hiremath, Amazon Web Services*
## Riepilogo
Questo modello fornisce esempi di codice e passaggi per installare i nodi di lavoro AWS Systems Manager (SSM Agent) e Amazon CloudWatch sul cloud Amazon Elastic Kubernetes Service (Amazon EKS) nel cloud Amazon Web Services (AWS) durante la creazione del cluster Amazon EKS. Puoi installare l'agente e CloudWatch l'agente SSM utilizzando la `preBootstrapCommands` proprietà dallo schema del [file di `eksctl` configurazione](https://eksctl.io/usage/schema/) (documentazione Weaveworks). Quindi, puoi utilizzare l'agente SSM per connetterti ai tuoi nodi di lavoro senza utilizzare una coppia di chiavi Amazon Elastic Compute Cloud EC2 (Amazon). Inoltre, puoi utilizzare l' CloudWatch agente per monitorare l'utilizzo della memoria e del disco sui nodi di lavoro Amazon EKS.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo
+ L'[utilità da riga di comando eksctl](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html), installata e configurata su macOS, Linux o Windows
+ L'[utilità da riga di comando kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html), installata e configurata su macOS, Linux o Windows
**Limitazioni**
+ Ti consigliamo di evitare di aggiungere script di lunga durata alla `preBootstrapCommands`**** proprietà, poiché ciò ritarda l'adesione del nodo al cluster Amazon EKS durante le attività di scalabilità. Ti consigliamo invece di creare un'[Amazon Machine Image (AMI) personalizzata](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.customenv.html).
+ Questo modello si applica solo alle istanze Amazon EC2 Linux.
## Architecture
**Stack tecnologico**
+ Amazon CloudWatch
+ Amazon Elastic Kubernetes Service (Amazon EKS)
+ AWS Systems Manager Parameter Store
**Architettura Target**
Il diagramma seguente mostra un esempio di utente che si connette ai nodi di lavoro di Amazon EKS utilizzando l'agente SSM che è stato installato utilizzando. `preBootstrapCommands`
![\[User connecting to Amazon EKS worker nodes via Systems Manager, with SSM Agent and CloudWatch agent on each node.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/b37a3cdb-204f-4014-8317-3600a793dac7/images/9a5760af-23bb-4616-97b0-b401a9d080cf.png)
Il diagramma mostra il flusso di lavoro seguente:
1. L'utente crea un cluster Amazon EKS utilizzando il file di `eksctl` configurazione con la `preBootstrapCommands` proprietà, che installa l'agente e CloudWatch l'agente SSM.
1. Tutte le nuove istanze che si uniscono al cluster in un secondo momento a causa delle attività di scalabilità vengono create con l'agente e l'agente SSM preinstallati. CloudWatch
1. L'utente si connette ad Amazon EC2 utilizzando l'agente SSM e quindi monitora l'utilizzo della memoria e del disco utilizzando l'agente. CloudWatch
## Tools (Strumenti)
+ [Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) ti CloudWatch aiuta a monitorare i parametri delle tue risorse AWS e delle applicazioni che esegui su AWS in tempo reale.
+ [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) EKS) ti aiuta a eseguire Kubernetes su AWS senza dover installare o gestire il tuo piano di controllo o i tuoi nodi Kubernetes.
+ [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) fornisce uno storage sicuro e gerarchico per la gestione dei dati di configurazione e la gestione dei segreti.
+ [AWS Systems Manager Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html) ti aiuta a gestire le EC2 istanze, le istanze locali e le macchine virtuali tramite una shell interattiva basata su browser con un solo clic o tramite l'AWS Command Line Interface (AWS CLI).
+ [eksctl](https://eksctl.io/usage/schema/) è un'utilità da riga di comando per la creazione e la gestione di cluster Kubernetes su Amazon EKS.
+ [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) è un'utilità a riga di comando per comunicare con il server API del cluster.
## Poemi epici
### Crea un cluster Amazon EKS.
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Memorizza il file di configurazione CloudWatch dell'agente. | Archivia il file di configurazione dell' CloudWatch agente in [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) nella regione AWS in cui desideri creare il tuo cluster Amazon EKS. A tale scopo, [crea un parametro](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) in AWS Systems Manager Parameter Store e annota il nome del parametro (ad esempio,`AmazonCloudwatch-linux`).Per ulteriori informazioni, consulta il codice del *file di configurazione dell' CloudWatch agente di esempio* nella sezione [Informazioni aggiuntive](#install-the-ssm-agent-and-cloudwatch-agent-on-amazon-eks-worker-nodes-using-prebootstrapcommands-additional) di questo modello. | DevOps ingegnere |
| Crea il file di configurazione eksctl e il cluster. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/install-the-ssm-agent-and-cloudwatch-agent-on-amazon-eks-worker-nodes-using-prebootstrapcommands.html) | AWS DevOps |
### Verifica che l'agente SSM e l' CloudWatch agente funzionino
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Prova l'agente SSM. | Usa SSH per connetterti ai nodi del cluster Amazon EKS utilizzando uno dei metodi descritti in [Avvia una sessione](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-sessions-start.html#start-ec2-console%20%20or%20https:%2F%2Fdocs.aws.amazon.com%2Fsystems-manager%2Flatest%2Fuserguide%2Fsession-manager-working-with-sessions-start.html%23sessions-start-cli) dalla documentazione di AWS Systems Manager. | AWS DevOps |
| Testa l' CloudWatch agente. | Usa la CloudWatch console per convalidare l' CloudWatch agente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/install-the-ssm-agent-and-cloudwatch-agent-on-amazon-eks-worker-nodes-using-prebootstrapcommands.html) | AWS DevOps |
## Risorse correlate
+ [Installazione ed esecuzione dell' CloudWatch agente sui tuoi server](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/install-CloudWatch-Agent-commandline-fleet.html) ( CloudWatch documentazione Amazon)
+ [Creare un parametro Systems Manager (console)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) (documentazione di AWS Systems Manager)
+ [Crea il file di configurazione CloudWatch dell'agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-cloudwatch-agent-configuration-file.html) ( CloudWatch documentazione Amazon)
+ [Avvio di una sessione (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-sessions-start.html#sessions-start-cli) (documentazione di AWS Systems Manager)
+ [Avvio di una sessione ( EC2 console Amazon)](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-sessions-start.html#start-ec2-console) (documentazione AWS Systems Manager)
## Informazioni aggiuntive
**Esempio di file di configurazione CloudWatch dell'agente**
Nell'esempio seguente, l' CloudWatch agente è configurato per monitorare l'utilizzo del disco e della memoria su istanze Amazon Linux:
```
{
"agent": {
"metrics_collection_interval": 60,
"run_as_user": "cwagent"
},
"metrics": {
"append_dimensions": {
"AutoScalingGroupName": "${aws:AutoScalingGroupName}",
"ImageId": "${aws:ImageId}",
"InstanceId": "${aws:InstanceId}",
"InstanceType": "${aws:InstanceType}"
},
"metrics_collected": {
"disk": {
"measurement": [
"used_percent"
],
"metrics_collection_interval": 60,
"resources": [
"*"
]
},
"mem": {
"measurement": [
"mem_used_percent"
],
"metrics_collection_interval": 60
}
}
}
}
```
**Esempio di file di configurazione eksctl**
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: test
region: us-east-2
version: "1.24"
managedNodeGroups:
- name: test
minSize: 2
maxSize: 4
desiredCapacity: 2
volumeSize: 20
instanceType: t3.medium
preBootstrapCommands:
- sudo yum install amazon-ssm-agent -y
- sudo systemctl enable amazon-ssm-agent
- sudo systemctl start amazon-ssm-agent
- sudo yum install amazon-cloudwatch-agent -y
- sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -s -c ssm:AmazonCloudwatch-linux
iam:
attachPolicyARNs:
- arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy
- arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy
- arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly
- arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy
- arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
```
**Dettagli aggiuntivi sul codice**
+ Nell'ultima riga della `preBootstrapCommands` proprietà, `AmazonCloudwatch-linux` c'è il nome del parametro creato in AWS System Manager Parameter Store. Devi includerlo `AmazonCloudwatch-linux` in Parameter Store nella stessa regione AWS in cui hai creato il cluster Amazon EKS. È anche possibile specificare un percorso di file, ma si consiglia di utilizzare Systems Manager per semplificare l'automazione e la riutilizzabilità.
+ Se lo usi `preBootstrapCommands` nel file di `eksctl` configurazione, vedrai due modelli di avvio nella Console di gestione AWS. Il primo modello di avvio include i comandi specificati in`preBootstrapCommands`. Il secondo modello include i comandi specificati `preBootstrapCommands` e i dati utente predefiniti di Amazon EKS. Questi dati sono necessari per far sì che i nodi entrino a far parte del cluster. Il gruppo Auto Scaling del gruppo di nodi utilizza questi dati utente per avviare nuove istanze.
+ Se utilizzi l'`iam`attributo nel file di `eksctl` configurazione, devi elencare le policy Amazon EKS predefinite con eventuali policy aggiuntive richieste nelle policy AWS Identity and Access Management (IAM) allegate. Nel frammento di codice del passaggio *Crea il file di configurazione eksctl e il cluster*, `AmazonSSMMangedInstanceCore` sono state aggiunte politiche aggiuntive per garantire che l' CloudWatch agente `CloudWatchAgentServerPolicy` e l'agente SSM funzionino come previsto. Le `AmazonEC2ContainerRegistryReadOnly` politiche `AmazonEKSWorkerNodePolicy``AmazonEKS_CNI_Policy`,, sono politiche obbligatorie necessarie per il corretto funzionamento del cluster Amazon EKS.
# Esegui la migrazione dei controller di ingresso NGINX quando abiliti la modalità automatica di Amazon EKS
*Olawale Olaleye e Shamanth Devagari, Amazon Web Services*
## Riepilogo
[La modalità automatica EKS](https://docs.aws.amazon.com/eks/latest/userguide/automode.html) per Amazon Elastic Kubernetes Service (Amazon EKS) può ridurre il sovraccarico operativo legato all'esecuzione dei carichi di lavoro sui cluster Kubernetes. Questa modalità consente anche di configurare e gestire AWS l'infrastruttura per tuo conto. Quando abiliti la modalità automatica EKS su un cluster esistente, devi pianificare attentamente la migrazione delle configurazioni di [NGINX Ingress](https://docs.nginx.com/nginx-ingress-controller/overview/about/) Controller. Questo perché il trasferimento diretto dei Network Load Balancer non è possibile.
Puoi utilizzare una strategia di blue/green distribuzione per migrare un'istanza di NGINX Ingress Controller quando abiliti EKS Auto Mode in un cluster Amazon EKS esistente.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS
+ Un [cluster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) che esegue Kubernetes versione 1.29 o successiva
+ Componenti aggiuntivi Amazon EKS con versioni [minime](https://docs.aws.amazon.com/eks/latest/userguide/auto-enable-existing.html#auto-addons-required)
+ [Ultima versione di kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html#kubectl-install-update)
+ Un'istanza esistente di [NGINX Ingress Controller](https://kubernetes.github.io/ingress-nginx/deploy/#aws)
+ (Facoltativo) Una [zona ospitata](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/hosted-zones-working-with.html) in Amazon Route 53 per lo spostamento del traffico basato su DNS
## Architecture
Una *distribuzione blu/verde* è una strategia di distribuzione in cui si creano due ambienti separati ma identici. Blue/green le implementazioni offrono funzionalità di downtime, release e rollback quasi nulle. L'idea fondamentale è spostare il traffico tra due ambienti identici che eseguono versioni diverse dell'applicazione.
L'immagine seguente mostra la migrazione dei Network Load Balancer da due diverse istanze di NGINX Ingress Controller quando si abilita la modalità automatica EKS. Si utilizza una blue/green distribuzione per spostare il traffico tra i due Network Load Balancer.
![\[Utilizzo di una strategia di blue/green implementazione per migrare le istanze di NGINX Ingress Controller.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/57e8c14f-cb50-4027-8ef6-ce8ea3f2db25/images/211a029a-90d8-4c92-8200-19e54062f936.png)
*Lo spazio dei nomi originale è lo spazio dei nomi blu.* È qui che vengono eseguiti il servizio e l'istanza originali di NGINX Ingress Controller, prima di abilitare la modalità automatica EKS. Il servizio e l'istanza originali si connettono a un Network Load Balancer con un nome DNS configurato in Route 53. Il [AWS Load Balancer Controller](https://kubernetes-sigs.github.io/aws-load-balancer-controller/v2.11/) ha distribuito questo Network Load Balancer nel cloud privato virtuale (VPC) di destinazione.
Il diagramma mostra il seguente flusso di lavoro per configurare un ambiente per una distribuzione: blue/green
1. *Installa e configura un'altra istanza di NGINX Ingress Controller in un namespace diverso, uno spazio dei nomi verde.*
1. In Route 53, configura un nome DNS per un nuovo Network Load Balancer.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) EKS) ti aiuta a eseguire AWS Kubernetes senza dover installare o gestire il tuo piano di controllo o i tuoi nodi Kubernetes.
+ [Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) distribuisce il traffico di applicazioni o di rete in entrata su più destinazioni. Ad esempio, puoi distribuire il traffico tra istanze Amazon Elastic Compute Cloud (Amazon EC2), contenitori e indirizzi IP in una o più zone di disponibilità.
+ [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) è un servizio Web DNS altamente scalabile e disponibile.
+ [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ti aiuta a lanciare AWS risorse in una rete virtuale che hai definito. Questa rete virtuale è simile a una comune rete da gestire all'interno del proprio data center, ma con i vantaggi dell'infrastruttura scalabile di AWS.
**Altri strumenti**
+ [Helm](https://helm.sh/) è un gestore di pacchetti open source per Kubernetes che ti aiuta a installare e gestire le applicazioni sul tuo cluster Kubernetes.
+ [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) è un'interfaccia a riga di comando che consente di eseguire comandi sui cluster Kubernetes.
+ [NGINX Ingress Controller](https://docs.nginx.com/nginx-ingress-controller/overview/about/) collega le app e i servizi Kubernetes con la gestione delle richieste, l'autenticazione, le risorse personalizzate self-service e il debug.
## Epiche
### Esamina l'ambiente esistente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Verifica che l'istanza originale di NGINX Ingress Controller sia operativa. | Immettete il seguente comando per verificare che le risorse nel `ingress-nginx` namespace siano operative. Se hai distribuito NGINX Ingress Controller in un altro spazio dei nomi, aggiorna il nome dello spazio dei nomi in questo comando.kubectl get all -n ingress-nginx
Nell'output, conferma che i pod di NGINX Ingress Controller siano in esecuzione. Di seguito è riportato un esempio di output:NAME READY STATUS RESTARTS AGE
pod/ingress-nginx-admission-create-xqn9d 0/1 Completed 0 88m
pod/ingress-nginx-admission-patch-lhk4j 0/1 Completed 1 88m
pod/ingress-nginx-controller-68f68f859-xrz74 1/1 Running 2 (10m ago) 72m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/ingress-nginx-controller LoadBalancer 10.100.67.255 k8s-ingressn-ingressn-abcdefg-12345.elb.eu-west-1.amazonaws.com 80:30330/TCP,443:31462/TCP 88m
service/ingress-nginx-controller-admission ClusterIP 10.100.201.176 443/TCP 88m
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/ingress-nginx-controller 1/1 1 1 88m
NAME DESIRED CURRENT READY AGE
replicaset.apps/ingress-nginx-controller-68f68f859 1 1 1 72m
replicaset.apps/ingress-nginx-controller-d8c96cf68 0 0 0 88m
NAME STATUS COMPLETIONS DURATION AGE
job.batch/ingress-nginx-admission-create Complete 1/1 4s 88m
job.batch/ingress-nginx-admission-patch Complete 1/1 5s 88m
| DevOps ingegnere |
### Implementa un HTTPd carico di lavoro di esempio per utilizzare NGINX Ingress Controller
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea le risorse Kubernetes. | Inserisci i seguenti comandi per creare un esempio di implementazione, servizio e ingresso Kubernetes:kubectl create deployment demo --image=httpd --port=80
kubectl expose deployment demo
kubectl create ingress demo --class=nginx \
--rule nginxautomode.local.dev/=demo:80
| DevOps ingegnere |
| Esamina le risorse distribuite. | Immettete il comando seguente per visualizzare un elenco delle risorse distribuite:kubectl get all,ingress
Nell'output, confermate che il HTTPd pod di esempio sia in esecuzione. Di seguito è riportato un esempio di output:NAME READY STATUS RESTARTS AGE
pod/demo-7d94f8cb4f-q68wc 1/1 Running 0 59m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/demo ClusterIP 10.100.78.155 80/TCP 59m
service/kubernetes ClusterIP 10.100.0.1 443/TCP 117m
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/demo 1/1 1 1 59m
NAME DESIRED CURRENT READY AGE
replicaset.apps/demo-7d94f8cb4f 1 1 1 59m
NAME CLASS HOSTS ADDRESS PORTS AGE
ingress.networking.k8s.io/demo nginx nginxautomode.local.dev k8s-ingressn-ingressn-abcdefg-12345.elb.eu-west-1.amazonaws.com 80 56m
| DevOps ingegnere |
| Conferma che il servizio è raggiungibile. | Immettere il seguente comando per confermare che il servizio è raggiungibile tramite il nome DNS del Network Load Balancer:curl -H "Host: nginxautomode.local.dev" http://k8s-ingressn-ingressn-abcdefg-12345.elb.eu-west-1.amazonaws.com
L'output previsto è il seguente:It works!
| DevOps ingegnere |
| (Facoltativo) Crea un record DNS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-nginx-ingress-controller-eks-auto-mode.html) | DevOps ingegnere, AWS DevOps |
### Abilita la modalità EKS Auto sul cluster esistente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Abilita la modalità automatica EKS. | Segui le istruzioni in [Abilita la modalità automatica EKS su un cluster esistente](https://docs.aws.amazon.com/eks/latest/userguide/auto-enable-existing.html) (documentazione Amazon EKS). | AWS DevOps |
### Installa un nuovo controller di ingresso NGINX
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura una nuova istanza di NGINX Ingress Controller. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-nginx-ingress-controller-eks-auto-mode.html) | DevOps ingegnere |
| Distribuisci la nuova istanza di NGINX Instance Controller. | Immettete il seguente comando per applicare il file manifest modificato:kubectl apply -f deploy.yaml
| DevOps ingegnere |
| Conferma la corretta implementazione. | Immettete il comando seguente per verificare che le risorse nel `ingress-nginx-v2` namespace siano operative:kubectl get all -n ingress-nginx-v2
Nell'output, conferma che i pod di NGINX Ingress Controller siano in esecuzione. Di seguito è riportato un esempio di output:NAME READY STATUS RESTARTS AGE
pod/ingress-nginx-admission-create-7shrj 0/1 Completed 0 24s
pod/ingress-nginx-admission-patch-vkxr5 0/1 Completed 1 24s
pod/ingress-nginx-controller-757bfcbc6d-4fw52 1/1 Running 0 24s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/ingress-nginx-controller LoadBalancer 10.100.208.114 k8s-ingressn-ingressn-2e5e37fab6-848337cd9c9d520f.elb.eu-west-1.amazonaws.com 80:31469/TCP,443:30658/TCP 24s
service/ingress-nginx-controller-admission ClusterIP 10.100.150.114 443/TCP 24s
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/ingress-nginx-controller 1/1 1 1 24s
NAME DESIRED CURRENT READY AGE
replicaset.apps/ingress-nginx-controller-757bfcbc6d 1 1 1 24s
NAME STATUS COMPLETIONS DURATION AGE
job.batch/ingress-nginx-admission-create Complete 1/1 4s 24s
job.batch/ingress-nginx-admission-patch Complete 1/1 5s 24s
| DevOps ingegnere |
| Crea un nuovo ingresso per il carico di HTTPd lavoro di esempio. | Immettete il seguente comando per creare un nuovo ingresso per il carico di lavoro di esempio esistente: HTTPd kubectl create ingress demo-new --class=nginx-v2 \
--rule nginxautomode.local.dev/=demo:80
| DevOps ingegnere |
| Conferma che il nuovo ingresso funzioni. | Immettete il seguente comando per confermare che il nuovo ingresso funzioni:curl -H "Host: nginxautomode.local.dev" k8s-ingressn-ingressn-2e5e37fab6-848337cd9c9d520f.elb.eu-west-1.amazonaws.com
L'output previsto è il seguente:It works!
| DevOps ingegnere |
### tagliare
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Passa al nuovo namespace. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-nginx-ingress-controller-eks-auto-mode.html) | AWS DevOps, DevOps ingegnere |
| Controlla i due ingressi. | Immettete il comando seguente per esaminare i due ingressi creati per il carico di lavoro di esempio HTTPd :kubectl get ingress
Di seguito è riportato un esempio di output:NAME CLASS HOSTS ADDRESS PORTS AGE
demo nginx nginxautomode.local.dev k8s-ingressn-ingressn-abcdefg-12345.elb.eu-west-1.amazonaws.com 80 95m
demo-new nginx-v2 nginxautomode.local.dev k8s-ingressn-ingressn-2e5e37fab6-848337cd9c9d520f.elb.eu-west-1.amazonaws.com 80 33s
| DevOps ingegnere |
## Risorse correlate
+ [Abilita la modalità automatica EKS su un cluster esistente](https://docs.aws.amazon.com/eks/latest/userguide/auto-enable-existing.html) (documentazione Amazon EKS)
+ [Risolvi i problemi relativi ai sistemi di bilanciamento del carico creati dal controller di servizio Kubernetes in Amazon](https://repost.aws/knowledge-center/eks-load-balancers-troubleshooting) EKS (re:POST Knowledge Center)AWS
+ [NGINX](https://docs.nginx.com/nginx-ingress-controller/) Ingress Controller (documentazione NGINX)
# Esegui la migrazione dei carichi di lavoro dei container da Azure Red Hat OpenShift (ARO) a Servizio Red Hat OpenShift su AWS (ROSA)
*Naveen Ramasamy, Srikanth Rangavajhala e Gireesh Sreekantan, Amazon Web Services*
## Riepilogo
[Questo modello fornisce step-by-step istruzioni per la migrazione dei carichi di lavoro dei container da Azure Red Hat (ARO) a (ROSA). OpenShift Servizio Red Hat OpenShift su AWS](https://aws.amazon.com/rosa/) ROSA è un servizio Kubernetes gestito fornito da Red Hat in collaborazione con. AWS Ti aiuta a implementare, gestire e scalare le tue applicazioni containerizzate utilizzando la piattaforma Kubernetes e sfrutta sia l'esperienza di Red Hat in Kubernetes che l'infrastruttura. Cloud AWS
La migrazione dei carichi di lavoro dei container da ARO, da altri cloud o dall'ambiente locale a ROSA comporta il trasferimento di applicazioni, configurazioni e dati da una piattaforma all'altra. Questo modello aiuta a garantire una transizione fluida ottimizzando al contempo Cloud AWS i servizi, la sicurezza e l'efficienza dei costi. Copre due metodi per la migrazione dei carichi di lavoro verso i cluster ROSA: CI/CD e Migration Toolkit for Containers (MTC).
Questo modello copre entrambi i metodi. Il metodo scelto dipende dalla complessità e dalla certezza del processo di migrazione. Se hai il pieno controllo sullo stato dell'applicazione e puoi garantire una configurazione coerente attraverso una pipeline, ti consigliamo di utilizzare questo CI/CD metodo. Tuttavia, se lo stato dell'applicazione comporta incertezze, cambiamenti imprevisti o un ecosistema complesso, consigliamo di utilizzare MTC come percorso affidabile e controllato per migrare l'applicazione e i relativi dati in un nuovo cluster. [Per un confronto dettagliato dei due metodi, consultate la sezione Informazioni aggiuntive.](#migrate-container-workloads-from-aro-to-rosa-additional)
Vantaggi della migrazione a ROSA:
+ ROSA si integra perfettamente con AWS come servizio nativo. È facilmente accessibile tramite Console di gestione AWS e fatturato tramite un unico. Account AWS Offre la piena compatibilità con gli altri Servizi AWS e fornisce supporto collaborativo sia da parte di Red Hat che da parte di Red AWS Hat.
+ ROSA supporta implementazioni ibride e multi-cloud. Consente alle applicazioni di funzionare in modo coerente tra data center locali e più ambienti cloud.
+ ROSA trae vantaggio dall'attenzione rivolta da Red Hat alla sicurezza e offre funzionalità come il controllo degli accessi basato sui ruoli (RBAC), la scansione delle immagini e la valutazione delle vulnerabilità per garantire un ambiente container sicuro.
+ ROSA è progettato per scalare facilmente le applicazioni e offre opzioni di alta disponibilità. Consente alle applicazioni di crescere secondo necessità mantenendo l'affidabilità.
+ ROSA automatizza e semplifica l'implementazione di un cluster Kubernetes rispetto ai metodi di configurazione e gestione manuali. Questo accelera il processo di sviluppo e implementazione.
+ ROSA trae vantaggio dai Cloud AWS servizi e offre una perfetta integrazione con AWS offerte come servizi di database, soluzioni di archiviazione e servizi di sicurezza.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo. Account AWS
+ Autorizzazioni configurate in base alle quali ROSA si basa per fornire funzionalità. Servizi AWS Per ulteriori informazioni, consulta [Prerequisiti](https://docs.aws.amazon.com/rosa/latest/userguide/set-up.html) nella documentazione ROSA.
+ ROSA è abilitato sulla [console ROSA](https://console.aws.amazon.com/rosa). Per istruzioni, consultate la [documentazione di ROSA](https://docs.aws.amazon.com/rosa/latest/userguide/set-up.html#enable-rosa).
+ Il cluster ROSA è stato installato e configurato. Per ulteriori informazioni, consulta la [Guida introduttiva a ROSA](https://docs.aws.amazon.com/rosa/latest/userguide/getting-started.html) nella documentazione di ROSA. Per comprendere i diversi metodi di configurazione di un cluster ROSA, consulta la Guida AWS prescrittiva alle strategie di [implementazione di ROSA](https://docs.aws.amazon.com/prescriptive-guidance/latest/red-hat-openshift-on-aws-implementation/).
+ [Connettività di rete stabilita dalla rete locale a quella AWS passante [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect.html)(preferita) o AWS Virtual Private Network ().Site-to-Site VPN](https://docs.aws.amazon.com/vpc/latest/userguide/vpn-connections.html)
+ Un'istanza Amazon Elastic Compute Cloud (Amazon EC2) o un altro server virtuale per installare strumenti come `aws client` client OpenShift CLI `oc` (), client ROSA e binario Git.
Prerequisiti aggiuntivi per il metodo: CI/CD
+ Accesso al server Jenkins locale con le autorizzazioni per creare una nuova pipeline, aggiungere fasi, aggiungere OpenShift cluster ed eseguire build.
+ Accesso al repository Git in cui viene mantenuto il codice sorgente dell'applicazione, con le autorizzazioni per creare un nuovo ramo Git ed eseguire commit sul nuovo ramo.
Prerequisiti aggiuntivi per il metodo MTC:
+ Un bucket Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3), che verrà utilizzato come repository di replica.
+ Accesso amministrativo al cluster ARO di origine. Ciò è necessario per configurare la connessione MTC.
**Limitazioni**
+ Alcuni Servizi AWS non sono disponibili in tutti Regioni AWS. Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
## Architecture
ROSA offre tre modelli di distribuzione di rete: pubblico, privato e. [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html) PrivateLinkconsente ai team di Red Hat Site Reliability Engineering (SRE) di gestire il cluster utilizzando una sottorete privata connessa all' PrivateLink endpoint del cluster in un VPC esistente.
La scelta dell' PrivateLinkopzione offre la configurazione più sicura. Per questo motivo, la consigliamo per carichi di lavoro sensibili o requisiti di conformità rigorosi. Per informazioni sulle opzioni di implementazione di reti pubbliche e private, consulta la [ OpenShift documentazione di Red Hat](https://docs.openshift.com/rosa/architecture/rosa-architecture-models.html#rosa-hcp-architecture_rosa-architecture-models).
**Importante**
È possibile creare un PrivateLink cluster solo al momento dell'installazione. Non è possibile modificare un cluster da utilizzare PrivateLink dopo l'installazione.
Il diagramma seguente illustra l' PrivateLink architettura di un cluster ROSA utilizzato Direct Connect per connettersi agli ambienti locali e ARO.
![\[Cluster ROSA che utilizza AWS Direct Connect e AWS PrivateLink.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/527cedfb-ec21-42be-bf21-d4e4e4f9db51/images/eff9b017-6fc7-4874-b610-849a42071ef4.png)
**AWS autorizzazioni per ROSA**
Per AWS le autorizzazioni a ROSA, ti consigliamo di utilizzare AWS Security Token Service (AWS STS) con token dinamici di breve durata. Questo metodo utilizza ruoli e politiche predefiniti con privilegi minimi per concedere a ROSA le autorizzazioni minime per operare in e supporta l'installazione Account AWS, il piano di controllo e le funzionalità di calcolo di ROSA.
**Ridistribuzione della pipeline CI/CD**
CI/CD pipeline redeployment is the recommended method for users who have a mature CI/CDgasdotto. Scegliendo questa opzione, è possibile utilizzare qualsiasi [strategia di DevOps implementazione](https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/deployment-strategies.html) per spostare gradualmente il carico delle applicazioni verso le distribuzioni su ROSA.
**Nota**
Questo modello presuppone un caso d'uso comune in cui si dispone di una pipeline Git, JFrog Artifactory e Jenkins locali. [Questo approccio richiede di stabilire la connettività di rete dalla rete locale a AWS quella esterna e di configurare il cluster ROSA prima di seguire le istruzioni nella sezione Epics. Direct Connect](#migrate-container-workloads-from-aro-to-rosa-epics) Per i dettagli, consulta la sezione [Prerequisiti](#migrate-container-workloads-from-aro-to-rosa-prereqs).
Il diagramma seguente mostra il flusso di lavoro per questo metodo.
![\[Migrazione dei contenitori da ARO a ROSA utilizzando il CI/CD metodo.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/527cedfb-ec21-42be-bf21-d4e4e4f9db51/images/f658590e-fbd9-4297-a02c-0b516694d436.png)
**Metodo MTC**
Puoi utilizzare [Migration Toolkit for Containers (MTC)](https://docs.openshift.com/container-platform/4.13/migration_toolkit_for_containers/about-mtc.html) per**** migrare i carichi di lavoro containerizzati tra diversi ambienti Kubernetes, ad esempio da ARO a ROSA. MTC semplifica il processo di migrazione automatizzando diverse attività chiave e fornendo un framework completo per la gestione del ciclo di vita della migrazione.
Il diagramma seguente mostra il flusso di lavoro per questo metodo.
![\[Migrazione dei contenitori da ARO a ROSA utilizzando il metodo MTC.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/527cedfb-ec21-42be-bf21-d4e4e4f9db51/images/979bbc7b-2e39-4dd1-b4f0-ea1032880a38.png)
## Tools (Strumenti)
**Servizi AWS**
+ [AWS DataSync](https://docs.aws.amazon.com/datasync/latest/userguide/what-is-datasync.html)è un servizio di trasferimento e individuazione di dati online che consente di spostare file o dati di oggetti da, verso e tra i servizi di AWS archiviazione.
+ [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html)collega la rete interna a una Direct Connect posizione tramite un cavo Ethernet standard in fibra ottica. Con questa connessione, è possibile creare interfacce virtuali direttamente al pubblico Servizi AWS ignorando i provider di servizi Internet nel percorso di rete.
+ [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html)ti aiuta a creare connessioni private unidirezionali dai tuoi cloud privati virtuali (VPCs) a servizi esterni al VPC.
+ [Servizio Red Hat OpenShift su AWS (ROSA)](https://docs.aws.amazon.com/rosa/latest/userguide/what-is-rosa.html) è un servizio gestito che aiuta OpenShift gli utenti Red Hat a creare, scalare e gestire applicazioni containerizzate su. AWS
+ [AWS Security Token Service (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) consente di richiedere credenziali temporanee con privilegi limitati per gli utenti.
**Altri strumenti**
+ [Migration Toolkit for Containers (MTC)](https://docs.openshift.com/container-platform/4.13/migration_toolkit_for_containers/about-mtc.html) fornisce una console e un'API per la migrazione di applicazioni containerizzate da ARO a ROSA.
## Best practice
+ Per la [resilienza](https://docs.aws.amazon.com/ROSA/latest/userguide/disaster-recovery-resiliency.html) e se disponi di carichi di lavoro di conformità alla sicurezza, configura un cluster ROSA Multi-AZ che utilizzi. PrivateLink [Per ulteriori informazioni, consulta la documentazione ROSA.](https://docs.aws.amazon.com/rosa/latest/userguide/getting-started-classic-private-link.html)
**Nota**
PrivateLink non può essere configurato dopo l'installazione.
+ Il bucket S3 utilizzato per l'archivio di replica non deve essere pubblico. Utilizza le policy dei bucket S3 appropriate per limitare l'accesso.
+ Se scegli il metodo MTC, utilizza l'opzione di migrazione **Stage** per ridurre la finestra di inattività durante il cutover.
+ Controllate le quote di servizio prima e dopo il provisioning del cluster ROSA. Se necessario, richiedete un aumento della quota in base alle vostre esigenze. Per ulteriori informazioni, consulta la pagina relativa alla [Documentazione sulle quote di servizio](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html).
+ Rivedi le [linee guida sulla sicurezza ROSA](https://docs.aws.amazon.com/ROSA/latest/userguide/security.html) e implementa le migliori pratiche di sicurezza.
+ Si consiglia di rimuovere l'amministratore predefinito del cluster dopo l'installazione. Per ulteriori informazioni, consulta la [ OpenShift documentazione di Red Hat](https://docs.openshift.com/container-platform/4.13/post_installation_configuration/cluster-tasks.html).
+ Utilizza la scalabilità automatica del pool di macchine per ridurre i nodi di lavoro inutilizzati nel cluster ROSA e ottimizzare i costi. Per ulteriori informazioni, consultate il [ROSA](https://catalog.workshops.aws/aws-openshift-workshop/en-US/5-nodes-storage/3-autoscale-machine-pool) Workshop.
+ Utilizza il servizio Red Hat Cost Management for OpenShift Container Platform per comprendere e monitorare meglio i costi di cloud e container. Per ulteriori informazioni, consulta il [ROSA Workshop](https://catalog.workshops.aws/aws-openshift-workshop/en-US/10-cost-management).
+ Monitora e verifica i servizi e le applicazioni dell'infrastruttura del cluster ROSA utilizzando Servizi AWS. Per ulteriori informazioni, vedere il [ROSA Workshop](https://catalog.workshops.aws/aws-openshift-workshop/en-US/8-observability).
## Epiche
### Opzione 1: utilizzare una pipeline CI/CD
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aggiungi il nuovo cluster ROSA a Jenkins. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-container-workloads-from-aro-to-rosa.html) | Amministratore AWS, amministratore di sistema AWS, AWS DevOps |
| Aggiungi il `oc` client ai tuoi nodi Jenkins. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-container-workloads-from-aro-to-rosa.html) | Amministratore AWS, amministratore di sistema AWS, AWS DevOps |
| Crea un nuovo ramo Git. | Crea un nuovo ramo nel tuo repository Git per`rosa-dev`. Questo ramo separa il codice o le modifiche ai parametri di configurazione per ROSA dalla pipeline esistente. | AWS DevOps |
| Tagga le immagini per ROSA. | Nella fase di creazione, usa un tag diverso per identificare le immagini create dalla pipeline ROSA. | Amministratore AWS, amministratore di sistema AWS, AWS DevOps |
| Creare una pipeline. | Crea una nuova pipeline Jenkins simile alla tua pipeline esistente. Per questa pipeline, usa il ramo `rosa-dev` Git che hai creato in precedenza e assicurati di includere le fasi di checkout, scansione del codice e compilazione di Git identiche alla pipeline esistente. | Amministratore AWS, amministratore di sistema AWS, AWS DevOps |
| Aggiungi una fase di distribuzione ROSA. | Nella nuova pipeline, aggiungi una fase da implementare nel cluster ROSA e fai riferimento al cluster ROSA che hai aggiunto alla configurazione globale di Jenkins. | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Inizia una nuova build. | In Jenkins, seleziona la tua pipeline e scegli **Costruisci ora**, oppure inizia una nuova build eseguendo una modifica al ramo `rosa-dev` in Git. | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Verifica la distribuzione. | Utilizzate il comando **oc** o la [console ROSA](https://console.aws.amazon.com/rosa) per verificare che l'applicazione sia stata distribuita sul cluster ROSA di destinazione. | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Copia i dati nel cluster di destinazione. | Per i carichi di lavoro con stato, copia i dati dal cluster di origine al cluster di destinazione utilizzando AWS DataSync le nostre utilità open source come **rsync** oppure puoi utilizzare il metodo MTC. Per ulteriori informazioni, consulta la [documentazione relativa ad AWS DataSync](https://docs.aws.amazon.com/datasync/latest/userguide/what-is-datasync.html). | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Testa la tua applicazione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-container-workloads-from-aro-to-rosa.html) | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Tagliare. | Se il test ha esito positivo, utilizza la policy Amazon Route 53 appropriata per spostare il traffico dall'applicazione ospitata da ARO all'applicazione ospitata da ROSA. Una volta completato questo passaggio, il carico di lavoro dell'applicazione passerà completamente al cluster ROSA. | Amministratore AWS, amministratore di sistema AWS |
### Opzione 2: usa MTC
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Installa l'operatore MTC. | Installa l'operatore MTC su entrambi i cluster ARO e ROSA:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-container-workloads-from-aro-to-rosa.html) | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Configura il traffico di rete verso l'archivio di replica. | Se utilizzi un server proxy, configuralo per consentire il traffico di rete tra l'archivio di replica e i cluster. Il repository di replica è un oggetto di storage intermedio che MTC utilizza per migrare i dati. I cluster di origine e di destinazione devono avere accesso di rete al repository di replica durante la migrazione. | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Aggiungi il cluster di origine a MTC. | Sulla console web MTC, aggiungete il cluster di origine ARO. | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Aggiungi Amazon S3 come repository di replica. | Sulla console web MTC, aggiungi il bucket Amazon S3 ([vedi](#migrate-container-workloads-from-aro-to-rosa-prereqs) Prerequisiti) come repository di replica. | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Crea un piano di migrazione. | Sulla console web MTC, create un piano di migrazione e specificate il tipo di trasferimento dei dati come **Copia**. Ciò indicherà a MTC di copiare i dati dal cluster di origine (ARO) al bucket S3 e dal bucket al cluster di destinazione (ROSA). | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
| Esegui il piano di migrazione. | Esegui il piano di migrazione utilizzando l'opzione **Stage** o **Cutover**:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/migrate-container-workloads-from-aro-to-rosa.html) | Amministratore AWS, AWS DevOps, amministratore di sistema AWS |
## risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| Problemi di connettività | Quando esegui la migrazione dei carichi di lavoro dei container da ARO a ROSA, potresti riscontrare problemi di connettività che devono essere risolti per garantire una migrazione di successo. Per risolvere questi problemi di connettività (elencati in questa tabella) durante la migrazione, sono fondamentali una pianificazione meticolosa, il coordinamento con i team di rete e sicurezza e test approfonditi. L'implementazione di una strategia di migrazione graduale e la verifica della connettività in ogni fase contribuiranno a ridurre al minimo le potenziali interruzioni e a garantire una transizione fluida da ARO a ROSA. |
| Differenze di configurazione di rete | ARO e ROSA potrebbero presentare variazioni nelle configurazioni di rete, come le impostazioni della rete virtuale (VNet), le sottoreti e le politiche di rete. Per una comunicazione corretta tra i servizi, assicuratevi che le impostazioni di rete siano allineate tra le due piattaforme. |
| Regole del gruppo di sicurezza e del firewall | ROSA e ARO potrebbero avere impostazioni predefinite diverse per il gruppo di sicurezza e il firewall. Assicurati di modificare e aggiornare queste regole per consentire il traffico necessario a mantenere la connettività tra contenitori e servizi durante la migrazione. |
| Modifiche all'indirizzo IP e al DNS | Durante la migrazione dei carichi di lavoro, gli indirizzi IP e i nomi DNS potrebbero cambiare. Riconfigura le applicazioni che si basano su nomi DNS statici IPs o specifici. |
| Accesso ai servizi esterni | Se l'applicazione dipende da servizi esterni come i database oppure APIs, potrebbe essere necessario aggiornare le impostazioni di connessione per assicurarsi che possano comunicare con i nuovi servizi di ROSA. |
| Configurazione di Azure Private Link | Se usi Azure Private Link o servizi endpoint privati in ARO, dovrai configurare la funzionalità equivalente in ROSA per garantire la connettività privata tra le risorse. |
| Site-to-Site VPN o configurazione Direct Connect | Se esistono Direct Connect connessioni Site-to-Site VPN o tra la rete locale e ARO, sarà necessario stabilire connessioni simili con ROSA per una comunicazione ininterrotta con le risorse locali. |
| Impostazioni di ingresso e bilanciamento del carico | Le configurazioni dei controller di ingresso e dei sistemi di bilanciamento del carico potrebbero differire tra ARO e ROSA. Riconfigurate queste impostazioni per mantenere l'accesso esterno ai vostri servizi. |
| Gestione di certificati e TLS | Se le tue applicazioni utilizzano certificati SSL o TLS, assicurati che i certificati siano validi e configurati correttamente in ROSA. |
| Accesso al registro dei contenitori | Se i contenitori sono ospitati in un registro di contenitori esterno, imposta l'autenticazione e le autorizzazioni di accesso appropriate per ROSA. |
| Monitoraggio e registrazione dei log | Aggiorna le configurazioni di monitoraggio e registrazione in modo da rispecchiare la nuova infrastruttura su ROSA in modo da poter continuare a monitorare efficacemente lo stato e le prestazioni dei tuoi contenitori. |
## Risorse correlate
**AWS****riferimenti**
+ [Che cos'è Servizio Red Hat OpenShift su AWS?](https://docs.aws.amazon.com/ROSA/latest/userguide/what-is-rosa.html) (documentazione ROSA)
+ [Inizia a usare ROSA](https://docs.aws.amazon.com/ROSA/latest/userguide/getting-started.html) (documentazione ROSA)
+ [Servizio Red Hat OpenShift su AWS strategie di implementazione](https://docs.aws.amazon.com/prescriptive-guidance/latest/red-hat-openshift-on-aws-implementation/) (AWS Prescriptive Guidance)
+ [Servizio Red Hat OpenShift su AWS Now GA](https://aws.amazon.com/blogs/aws/red-hat-openshift-service-on-aws-now-generally-availably/) (AWS post sul blog)
+ [Workshop ROSA](https://catalog.workshops.aws/aws-openshift-workshop/en-US/0-introduction)
+ [Domande frequenti su ROSA](https://aws.amazon.com/rosa/faqs/)
+ [Domande frequenti sul seminario ROSA](https://www.rosaworkshop.io/rosa/14-faq/)
+ [Prezzi ROSA](https://aws.amazon.com/rosa/pricing/)
** OpenShift Documentazione Red Hat**
+ [Installazione rapida di un cluster su AWS](https://docs.openshift.com/container-platform/4.13/installing/installing_aws/installing-aws-default.html)
+ [Installazione di un cluster AWS in una rete con restrizioni](https://docs.openshift.com/container-platform/4.13/installing/installing_aws/installing-restricted-networks-aws-installer-provisioned.html)
+ [Installazione di un cluster AWS in un VPC esistente](https://docs.openshift.com/container-platform/4.13/installing/installing_aws/installing-aws-vpc.html)
+ [Installazione di un cluster su un'infrastruttura fornita dall'utente tramite modelli AWS CloudFormation ](https://docs.openshift.com/container-platform/4.13/installing/installing_aws/installing-aws-user-infra.html)
+ [Installazione di un cluster AWS in una rete limitata con un'infrastruttura fornita dall'utente](https://docs.openshift.com/container-platform/4.13/installing/installing_aws/installing-restricted-networks-aws.html)
+ [Installazione di un cluster con personalizzazioni AWS](https://docs.openshift.com/container-platform/4.13/installing/installing_aws/installing-aws-customizations.html)
+ [Guida introduttiva alla OpenShift CLI](https://docs.openshift.com/container-platform/4.13/cli_reference/openshift_cli/getting-started-cli.html)
## Informazioni aggiuntive
**Scelta tra MTC e le opzioni di ridistribuzione della CI/CD pipeline**
La migrazione delle applicazioni da un OpenShift cluster a un altro richiede un'attenta considerazione. Idealmente, si vorrebbe una transizione fluida utilizzando una CI/CD pipeline per ridistribuire l'applicazione e gestire la migrazione dei dati di volume persistenti. Tuttavia, in pratica, un'applicazione in esecuzione su un cluster è suscettibile di modifiche impreviste nel tempo. Queste modifiche possono far sì che l'applicazione si discosti gradualmente dallo stato di distribuzione originale. MTC offre una soluzione per scenari in cui il contenuto esatto di un namespace è incerto ed è importante una migrazione senza interruzioni di tutti i componenti dell'applicazione in un nuovo cluster.
Fare la scelta giusta richiede la valutazione dello scenario specifico e la valutazione dei vantaggi di ciascun approccio. In questo modo, potete garantire una migrazione efficace e senza interruzioni, in linea con le vostre esigenze e priorità. Di seguito sono riportate ulteriori linee guida per la scelta tra le due opzioni.
**Ridistribuzione della pipeline CI/CD**
Il metodo della CI/CD pipeline è l'approccio consigliato se l'applicazione può essere ridistribuita con sicurezza utilizzando una pipeline. Ciò garantisce che la migrazione sia controllata, prevedibile e allineata alle pratiche di distribuzione esistenti. Scegliendo questo metodo, è possibile utilizzare strategie di [implementazione blu/green](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/bluegreen-deployments.html) o canary per spostare gradualmente il carico sulle implementazioni su ROSA. In questo scenario, questo modello presuppone che Jenkins stia orchestrando le distribuzioni delle applicazioni dall'ambiente locale.
Vantaggi:
+ Non è necessario l'accesso amministrativo al cluster ARO di origine né è necessario distribuire operatori sul cluster di origine o di destinazione.
+ Questo approccio consente di modificare gradualmente il traffico utilizzando una DevOps strategia.
Svantaggi:
+ È necessario uno sforzo maggiore per testare la funzionalità dell'applicazione.
+ Se l'applicazione contiene dati persistenti, sono necessari passaggi aggiuntivi per copiare i dati utilizzando AWS DataSync o altri strumenti.
**Migrazione MTC**
Nel mondo reale, le applicazioni in esecuzione possono subire modifiche impreviste che le allontanano dalla distribuzione iniziale. Scegliete l'opzione MTC quando non siete sicuri dello stato attuale dell'applicazione nel cluster di origine. Ad esempio, se il vostro ecosistema applicativo comprende vari componenti, configurazioni e volumi di archiviazione dei dati, vi consigliamo di scegliere MTC per garantire una migrazione completa che copra l'applicazione e il suo intero ambiente.
Vantaggi:
+ MTC fornisce il backup e il ripristino completi del carico di lavoro.
+ Copierà i dati persistenti dall'origine alla destinazione durante la migrazione del carico di lavoro.
+ Non richiede l'accesso all'archivio del codice sorgente.
Svantaggi:
+ Sono necessari i privilegi amministrativi per installare l'operatore MTC sui cluster di origine e di destinazione.
+ Il DevOps team richiede una formazione per utilizzare lo strumento MTC ed eseguire le migrazioni.
# Esegui attività Amazon ECS su Amazon WorkSpaces con Amazon ECS Anywhere
*Akash Kumar, Amazon Web Services*
## Riepilogo
Amazon Elastic Container Service (Amazon ECS) Anywhere supporta la distribuzione di attività Amazon ECS in qualsiasi ambiente, inclusa l'infrastruttura gestita di Amazon Web Services (AWS) e l'infrastruttura gestita dai clienti. Puoi farlo utilizzando un piano di controllo completamente gestito da AWS, in esecuzione nel cloud e sempre aggiornato.
Le aziende utilizzano spesso Amazon WorkSpaces per lo sviluppo di applicazioni basate su container. Ciò ha richiesto Amazon Elastic Compute Cloud (Amazon EC2) o AWS Fargate con un cluster Amazon ECS per testare ed eseguire le attività ECS. Ora, utilizzando Amazon ECS Anywhere, puoi aggiungere WorkSpaces Amazon come istanze esterne direttamente a un cluster ECS ed eseguire le tue attività direttamente. Ciò riduce i tempi di sviluppo, poiché puoi testare il tuo contenitore con un cluster ECS localmente su Amazon WorkSpaces. Puoi anche risparmiare sui costi di utilizzo EC2 delle istanze Fargate per testare le tue applicazioni container.
Questo modello mostra come distribuire le attività ECS su Amazon WorkSpaces con Amazon ECS Anywhere. Configura il cluster ECS e utilizza AWS Directory Service Simple AD per avviare il WorkSpaces. Quindi l'attività ECS di esempio avvia NGINX in. WorkSpaces
## Prerequisiti e limitazioni
+ Un account AWS attivo
+ Interfaccia a riga di comando di AWS (CLI AWS)
+ Credenziali AWS [configurate sulla tua macchina](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html)
## Architecture
**Stack tecnologico Target**
+ Un cloud privato virtuale (VPC)
+ Un cluster Amazon ECS
+ Amazon WorkSpaces
+ AWS Directory Service con Simple AD
**Architettura Target**
![\[ECS Anywhere configura il cluster ECS e utilizza Simple AD per l'avvio. WorkSpaces\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/da8b2249-3423-485c-9fef-6f902025e969/images/fd354d14-f29b-4b9e-8f1a-c3cb7ed4d6bf.png)
L'architettura include i seguenti servizi e risorse:
+ Un cluster ECS con sottoreti pubbliche e private in un VPC personalizzato
+ Simple AD nel VPC per fornire agli utenti l'accesso ad Amazon WorkSpaces
+ Amazon ha effettuato il WorkSpaces provisioning nel VPC utilizzando Simple AD
+ AWS Systems Manager attivato per aggiungere Amazon WorkSpaces come istanze gestite
+ Utilizzando Amazon ECS e AWS Systems Manager Agent (SSM Agent), Amazon si è WorkSpaces aggiunto a Systems Manager e al cluster ECS
+ Un esempio di attività ECS da eseguire nel cluster ECS WorkSpaces
## Tools (Strumenti)
+ [AWS Directory Service Simple Active Directory (Simple AD)](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_simple_ad.html) è una directory gestita autonoma alimentata da un server compatibile con Active Directory Samba 4. Simple AD fornisce un sottoinsieme delle funzionalità offerte da AWS Managed Microsoft AD, inclusa la capacità di gestire gli utenti e di connettersi in modo sicuro alle istanze Amazon EC2 .
+ [Amazon Elastic Container Service (Amazon ECS)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) è un servizio rapido e scalabile di gestione dei container che ti aiuta a eseguire, arrestare e gestire container in un cluster.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue risorse AWS controllando chi è autenticato e autorizzato a utilizzarle.
+ [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) ti aiuta a gestire le applicazioni e l'infrastruttura in esecuzione nel cloud AWS. Semplifica la gestione delle applicazioni e delle risorse, riduce i tempi di rilevamento e risoluzione dei problemi operativi e ti aiuta a gestire le tue risorse AWS in modo sicuro su larga scala.
+ [Amazon](https://docs.aws.amazon.com/workspaces/latest/adminguide/amazon-workspaces.html) ti WorkSpaces aiuta a fornire desktop Microsoft Windows o Amazon Linux virtuali basati sul cloud per i tuoi utenti, noti come. *WorkSpaces* WorkSpaces elimina la necessità di procurarsi e distribuire hardware o installare software complessi.
## Epiche
### Configura il cluster ECS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea e configura il cluster ECS. | Per creare il cluster ECS, segui le istruzioni nella [documentazione AWS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html), inclusi i seguenti passaggi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-amazon-ecs-tasks-on-amazon-workspaces-with-amazon-ecs-anywhere.html) | Architetto del cloud |
### Avvia Amazon WorkSpaces
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura Simple AD e avvia Amazon WorkSpaces. | Per effettuare il provisioning di una directory Simple AD per il tuo VPC appena creato e avviare Amazon WorkSpaces, segui le istruzioni nella documentazione [AWS](https://docs.aws.amazon.com/workspaces/latest/adminguide/launch-workspace-simple-ad.html). | Architetto del cloud |
### Configurare AWS Systems Manager per un ambiente ibrido
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Scarica gli script allegati. | Sul computer locale, scaricate i `ssm-activation.json` file `ssm-trust-policy.json` e contenuti nella sezione *Allegati.* | Architetto del cloud |
| Aggiungi il ruolo IAM. | Aggiungi variabili di ambiente in base ai tuoi requisiti aziendali.export AWS_DEFAULT_REGION=${AWS_REGION_ID}
export ROLE_NAME=${ECS_TASK_ROLE}
export CLUSTER_NAME=${ECS_CLUSTER_NAME}
export SERVICE_NAME=${ECS_CLUSTER_SERVICE_NAME}Eseguire il seguente comando seguente.aws iam create-role --role-name $ROLE_NAME --assume-role-policy-document file://ssm-trust-policy.json
| Architetto del cloud |
| Aggiungi la SSMManaged InstanceCore policy di Amazon al ruolo IAM. | Eseguire il seguente comando seguente.aws iam attach-role-policy --role-name $ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
| Architetto del cloud |
| Aggiungi la policy Amazon EC2 ContainerServicefor EC2 Role al ruolo IAM. | Eseguire il seguente comando seguente.aws iam attach-role-policy --role-name $ROLE_NAME --policy-arn arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role
| Architetto del cloud |
| Verifica il ruolo IAM. | Per verificare il ruolo IAM, esegui il comando seguente.aws iam list-attached-role-policies --role-name $ROLE_NAME
| Architetto del cloud |
| Attiva Systems Manager. | Eseguire il seguente comando seguente.aws ssm create-activation --iam-role $ROLE_NAME | tee ssm-activation.json
| Architetto del cloud |
### Aggiungi WorkSpaces al cluster ECS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Connect al tuo WorkSpaces. | Per connetterti e configurare i tuoi spazi di lavoro, segui le istruzioni nella [documentazione AWS](https://docs.aws.amazon.com/workspaces/latest/userguide/workspaces-user-getting-started.html). | Sviluppatore di app |
| Scarica lo script di installazione ecs-anywhere. | Nel prompt dei comandi, eseguire il seguente comando .curl -o "ecs-anywhere-install.sh" "https://amazon-ecs-agent-packages-preview.s3.us-east-1.amazonaws.com/ecs-anywhere-install.sh" && sudo chmod +x ecs-anywhere-install.sh
| Sviluppatore di app |
| Verifica l'integrità dello script della shell. | (Facoltativo) Eseguite il comando seguente.curl -o "ecs-anywhere-install.sh.sha256" "https://amazon-ecs-agent-packages-preview.s3.us-east-1.amazonaws.com/ecs-anywhere-install.sh.sha256" && sha256sum -c ecs-anywhere-install.sh.sha256
| Sviluppatore di app |
| Aggiungi un repository EPEL su Amazon Linux. | Per aggiungere un repository Extra Packages for Enterprise Linux (EPEL), esegui il comando. `sudo amazon-linux-extras install epel -y` | Sviluppatore di app |
| Installa Amazon ECS Anywhere. | Per eseguire lo script di installazione, usa il seguente comando.sudo ./ecs-anywhere-install.sh --cluster $CLUSTER_NAME --activation-id $ACTIVATION_ID --activation-code $ACTIVATION_CODE --region $AWS_REGION
| |
| Controlla le informazioni sull'istanza dal cluster ECS. | Per controllare le informazioni sulle istanze del cluster Systems Manager ed ECS e convalidare quelle WorkSpaces aggiunte al cluster, esegui il comando seguente dal computer locale.aws ssm describe-instance-information" && "aws ecs list-container-instances --cluster $CLUSTER_NAME
| Sviluppatore di app |
### Aggiungi un'attività ECS per WorkSpaces
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un ruolo IAM per l'esecuzione delle attività. | Scarica `task-execution-assume-role.json` e `external-task-definition.json` dalla sezione *Allegati.* Sul computer locale, esegui il seguente comando.aws iam --region $AWS_DEFAULT_REGION create-role --role-name $ECS_TASK_EXECUTION_ROLE --assume-role-policy-document file://task-execution-assume-role.json
| Architetto del cloud |
| Aggiungi la policy al ruolo di esecuzione. | Eseguire il seguente comando seguente.aws iam --region $AWS_DEFAULT_REGION attach-role-policy --role-name $ECS_TASK_EXECUTION_ROLE --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
| Architetto del cloud |
| Crea un ruolo da svolgere. | Eseguire il seguente comando seguente.aws iam --region $AWS_DEFAULT_REGION create-role --role-name $ECS_TASK_EXECUTION_ROLE --assume-role-policy-document file://task-execution-assume-role.json
| Architetto del cloud |
| Registra la definizione dell'attività nel cluster. | Sul computer locale, esegui il comando seguente.aws ecs register-task-definition --cli-input-json file://external-task-definition.json
| Architetto del cloud |
| Esegui l'attività. | Sul computer locale, esegui il comando seguente.aws ecs run-task --cluster $CLUSTER_NAME --launch-type EXTERNAL --task-definition nginx
| Architetto del cloud |
| Convalida lo stato di esecuzione dell'attività. | Per recuperare l'ID dell'attività, esegui il comando seguente.export TEST_TASKID=$(aws ecs list-tasks --cluster $CLUSTER_NAME | jq -r '.taskArns[0]')
Con l'ID dell'attività, esegui il comando seguente.aws ecs describe-tasks --cluster $CLUSTER_NAME --tasks ${TEST_TASKID} | Architetto del cloud |
| Verifica l'attività su WorkSpace. | Per verificare che NGINX sia in esecuzione su WorkSpace, esegui il comando. ` curl http://localhost:8080` | Sviluppatore di app |
## Risorse correlate
+ [Cluster ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html)
+ [Configurazione di un ambiente ibrido](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-managedinstances.html)
+ [Amazon WorkSpaces](https://docs.aws.amazon.com/workspaces/latest/adminguide/amazon-workspaces.html)
+ [Simple AD](https://docs.aws.amazon.com/workspaces/latest/adminguide/launch-workspace-simple-ad.html)
## Allegati
[Per accedere al contenuto aggiuntivo associato a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/da8b2249-3423-485c-9fef-6f902025e969/attachments/attachment.zip)
# Esegui un contenitore Docker dell'API Web ASP.NET Core su un'istanza Amazon Linux EC2
*Vijai Anand Ramalingam e Sreelaxmi Pai, Amazon Web Services*
## Riepilogo
Questo modello è destinato alle persone che stanno iniziando a containerizzare le proprie applicazioni sul cloud Amazon Web Services (AWS). Quando inizi a containerizzare le app sul cloud, di solito non sono configurate piattaforme di orchestrazione dei container. Questo modello ti aiuta a configurare rapidamente l'infrastruttura su AWS per testare le tue applicazioni containerizzate senza bisogno di un'elaborata infrastruttura di orchestrazione dei container.
Il primo passo nel percorso di modernizzazione consiste nel trasformare l'applicazione. Se si tratta di un'applicazione.NET Framework legacy, è necessario innanzitutto modificare il runtime in ASP.NET Core. Quindi, esegui queste operazioni:
+ Crea l'immagine del contenitore Docker
+ Esegui il contenitore Docker utilizzando l'immagine integrata
+ Convalida l'applicazione prima di distribuirla su qualsiasi piattaforma di orchestrazione dei container, come Amazon Elastic Container Service (Amazon ECS) o Amazon Elastic Kubernetes Service (Amazon EKS).
Questo modello copre gli aspetti di creazione, esecuzione e convalida dello sviluppo di applicazioni moderne su un'istanza Amazon Elastic Compute Cloud EC2 (Amazon) Linux.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un [account Amazon Web Services (AWS)](https://aws.amazon.com/account/) attivo
+ Un [ruolo AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) con accesso sufficiente per creare risorse AWS per questo modello
+ Scaricato e installato [Visual Studio Community 2022](https://visualstudio.microsoft.com/downloads/) o versione successiva
+ Un progetto.NET Framework modernizzato in ASP.NET Core
+ Un repository GitHub
**Versioni del prodotto**
+ Visual Studio Community 2022 o versioni successive
## Architecture
**Architettura Target**
Questo modello utilizza un [ CloudFormation modello AWS](https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?stackName=SSM-SSH-Demo&templateURL=https://aws-quickstart.s3.amazonaws.com/quickstart-examples/samples/session-manager-ssh/session-manager-example.yaml) per creare l'architettura ad alta disponibilità mostrata nel diagramma seguente. Un'istanza Amazon EC2 Linux viene avviata in una sottorete privata. AWS Systems Manager Session Manager viene utilizzato per accedere all'istanza privata di Amazon EC2 Linux e per testare l'API in esecuzione nel contenitore Docker.
![\[Un utente che accede all'istanza Amazon EC2 Linux e testa l'API in esecuzione nel contenitore Docker.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/512e61b2-10ba-43be-bbd8-2bdc597c3de3/images/9c5206f6-32b1-47be-9037-360c0bff713c.png)
1. Accesso all'istanza Linux tramite Session Manager
## Tools (Strumenti)
**Servizi AWS**
+ [Interfaccia a riga di comando AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html): AWS Command Line Interface (AWS CLI) è uno strumento open source per interagire con i servizi AWS tramite comandi nella shell della riga di comando. Con una configurazione minima, puoi eseguire comandi AWS CLI che implementano funzionalità equivalenti a quelle fornite dalla Console di gestione AWS basata su browser.
+ [Console di gestione AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/learn-whats-new.html): la Console di gestione AWS è un'applicazione Web che comprende e fa riferimento a un'ampia raccolta di console di servizio per la gestione delle risorse AWS. Quando effettui l'accesso per la prima volta, visualizzi la home page della console. La home page fornisce l'accesso a ciascuna console di servizio e offre un unico posto per accedere alle informazioni necessarie per eseguire le attività relative ad AWS.
+ [AWS Systems Manager Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html) — Session Manager è una funzionalità di AWS Systems Manager completamente gestita. Con Session Manager, puoi gestire le tue istanze Amazon Elastic Compute Cloud (Amazon EC2). Session Manager fornisce una gestione sicura e verificabile dei nodi senza la necessità di aprire porte in entrata, gestire host bastion o gestire chiavi SSH.
**Altri strumenti**
+ [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) — Visual Studio 2022 è un ambiente di sviluppo integrato (IDE).
+ [Docker](https://www.docker.com/): Docker è un set di prodotti Platform as a Service (PaaS) che utilizzano la virtualizzazione a livello di sistema operativo per fornire software in contenitori.
**Codice**
```
FROM mcr.microsoft.com/dotnet/aspnet:5.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443
FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build
WORKDIR /src
COPY ["DemoNetCoreWebAPI/DemoNetCoreWebAPI.csproj", "DemoNetCoreWebAPI/"]
RUN dotnet restore "DemoNetCoreWebAPI/DemoNetCoreWebAPI.csproj"
COPY . .
WORKDIR "/src/DemoNetCoreWebAPI"
RUN dotnet build "DemoNetCoreWebAPI.csproj" -c Release -o /app/build
FROM build AS publish
RUN dotnet publish "DemoNetCoreWebAPI.csproj" -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "DemoNetCoreWebAPI.dll"]
```
## Epiche
### Sviluppa l'API web ASP.NET Core
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un esempio di API Web ASP.NET Core utilizzando Visual Studio. | Per creare un esempio di API web ASP.NET Core, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html) | Sviluppatore di app |
| Crea un Dockerfile. | Per creare un Dockerfile, esegui una delle seguenti operazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html)Per inviare le modifiche al tuo GitHub repository, esegui il comando seguente.git add --all
git commit -m "Dockerfile added"
git push
| Sviluppatore di app |
### Configurare l'istanza Amazon EC2 Linux
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura l'infrastruttura. | Avvia il [ CloudFormation modello AWS](https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?stackName=SSM-SSH-Demo&templateURL=https://aws-quickstart.s3.amazonaws.com/quickstart-examples/samples/session-manager-ssh/session-manager-example.yaml) per creare l'infrastruttura, che include quanto segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html)Per ulteriori informazioni sull'accesso a un' EC2 istanza Amazon privata utilizzando Session Manager senza richiedere un host bastion, consulta il post sul blog [Toward a bastion-less world](https://aws.amazon.com/blogs/infrastructure-and-automation/toward-a-bastion-less-world/). | Sviluppatore di app, amministratore AWS, AWS DevOps |
| Accedi all'istanza Amazon EC2 Linux. | Per connetterti all'istanza Amazon EC2 Linux nella sottorete privata, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html) | Sviluppatore di app |
| Installa e avvia Docker. | Per installare e avviare Docker nell'istanza Amazon EC2 Linux, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html) | Sviluppatore di app, amministratore AWS, AWS DevOps |
| Installa Git e clona il repository. | Per installare Git sull'istanza Amazon EC2 Linux e clonare il repository GitHub, procedi come segue.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html) | Sviluppatore di app, amministratore AWS, AWS DevOps |
| Crea ed esegui il contenitore Docker. | Per creare l'immagine Docker ed eseguire il contenitore all'interno dell'istanza Amazon EC2 Linux, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html) | Sviluppatore di app, amministratore AWS, AWS DevOps |
### Testa l'API web
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Testa l'API web usando il comando curl. | Per testare l'API web, esegui il comando seguente.curl -X GET "http://localhost/WeatherForecast" -H "accept: text/plain"
Verifica la risposta dell'API.Puoi ottenere i comandi curl per ogni endpoint da Swagger quando lo esegui localmente. | Sviluppatore di app |
### Eseguire la pulizia delle risorse
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Eliminare tutte le risorse. | Elimina lo stack per rimuovere tutte le risorse. In questo modo non ti verranno addebitati costi per i servizi che non utilizzi. | Amministratore AWS, AWS DevOps |
## Risorse correlate
+ [Connect alla propria istanza Linux da Windows utilizzando PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html)
+ [Crea un'API web con ASP.NET Core](https://docs.microsoft.com/en-us/aspnet/core/tutorials/first-web-api?view=aspnetcore-5.0&tabs=visual-studio)
+ [Verso un mondo senza bastioni](https://aws.amazon.com/blogs/infrastructure-and-automation/toward-a-bastion-less-world/)
# Esegui carichi di lavoro con stato con storage persistente dei dati utilizzando Amazon EFS su Amazon EKS con AWS Fargate
*Ricardo Morais, Rodrigo Bersa e Lucio Pereira, Amazon Web Services*
## Riepilogo
Questo modello fornisce indicazioni per abilitare Amazon Elastic File System (Amazon EFS) come dispositivo di storage per contenitori in esecuzione su Amazon Elastic Kubernetes Service (Amazon EKS) utilizzando AWS Fargate per il provisioning delle risorse di calcolo.
La configurazione descritta in questo modello segue le migliori pratiche di sicurezza e fornisce sicurezza a riposo e sicurezza in transito per impostazione predefinita. Per crittografare il tuo file system Amazon EFS, utilizza una chiave AWS Key Management Service (AWS KMS), ma puoi anche specificare un alias chiave che esegua il processo di creazione di una chiave KMS.
Puoi seguire i passaggi di questo schema per creare uno spazio dei nomi e un profilo Fargate per un'applicazione proof-of-concept (PoC), installare il driver Amazon EFS Container Storage Interface (CSI) utilizzato per integrare il cluster Kubernetes con Amazon EFS, configurare la classe di storage e distribuire l'applicazione PoC. Questi passaggi portano a un file system Amazon EFS condiviso tra più carichi di lavoro Kubernetes, in esecuzione su Fargate. Lo schema è accompagnato da script che automatizzano questi passaggi.
È possibile utilizzare questo modello se si desidera la persistenza dei dati nelle applicazioni containerizzate ed evitare la perdita di dati durante le operazioni di scalabilità. Esempio:
+ **DevOps strumenti** — Uno scenario comune è lo sviluppo di uno strumento di integrazione e distribuzione continua (strumento). CI/CD) strategy. In this case, you can use Amazon EFS as a shared file system to store configurations among different instances of the CI/CD tool or to store a cache (for example, an Apache Maven repository) for pipeline stages among different instances of the CI/CD
+ **Server Web**: uno scenario comune consiste nell'utilizzare Apache come server Web HTTP. Puoi usare Amazon EFS come file system condiviso per archiviare file statici condivisi tra diverse istanze del server Web. In questo scenario di esempio, le modifiche vengono applicate direttamente al file system anziché inserire file statici in un'immagine Docker.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo
+ Un cluster Amazon EKS esistente con Kubernetes versione 1.17 o successiva (testato fino alla versione 1.27)
+ Un file system Amazon EFS esistente per associare un Kubernetes StorageClass e fornire i file system in modo dinamico
+ Autorizzazioni di amministrazione del cluster
+ Contesto configurato per puntare al cluster Amazon EKS desiderato
**Limitazioni**
+ Ci sono alcune limitazioni da considerare quando usi Amazon EKS con Fargate. Ad esempio, l'uso di alcuni costrutti Kubernetes, come DaemonSets i contenitori privilegiati, non è supportato. Per ulteriori informazioni sulle limitazioni di Fargate, consulta le [considerazioni su AWS Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html#fargate-considerations) nella documentazione di Amazon EKS.
+ Il codice fornito con questo pattern supporta le workstation che eseguono Linux o macOS.
**Versioni del prodotto**
+ AWS Command Line Interface (AWS CLI) versione 2 o successiva
+ Driver Amazon EFS CSI versione 1.0 o successiva (testato fino alla versione 2.4.8)
+ eksctl versione 0.24.0 o successiva (testato fino alla versione 0.158.0)
+ jq versione 1.6 o successiva
+ kubectl versione 1.17 o successiva (testata fino alla versione 1.27)
+ Kubernetes versione 1.17 o successiva (testato fino alla versione 1.27)
## Architecture
![\[Diagramma dell'architettura dell'esecuzione di carichi di lavoro con stato con storage persistente dei dati utilizzando Amazon EFS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/2487e285-269b-415b-a270-877f973e3aaf/images/ec8de63c-3307-4010-9e03-2bd7b9881fff.png)
L'architettura di destinazione è composta dalla seguente infrastruttura:
+ Un cloud privato virtuale (VPC)
+ Due zone di disponibilità
+ Una sottorete pubblica con un gateway NAT che fornisce l'accesso a Internet
+ Una sottorete privata con un cluster Amazon EKS e target di montaggio Amazon EFS (noti anche come *punti di montaggio*)
+ Amazon EFS a livello di VPC
Di seguito è riportata l'infrastruttura ambientale per il cluster Amazon EKS:
+ Profili AWS Fargate che supportano i costrutti Kubernetes a livello di namespace
+ Uno spazio dei nomi Kubernetes con:
+ Due pod applicativi distribuiti tra le zone di disponibilità
+ Una dichiarazione di volume persistente (PVC) associata a un volume persistente (PV) a livello di cluster
+ Un PV a livello di cluster associato al PVC nello spazio dei nomi e che punta alle destinazioni di montaggio di Amazon EFS nella sottorete privata, all'esterno del cluster
## Tools (Strumenti)
**Servizi AWS**
+ [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento open source che puoi usare per interagire con i servizi AWS dalla riga di comando.
+ [Amazon Elastic File System (Amazon EFS)](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) ti aiuta a creare e configurare file system condivisi nel cloud AWS. In questo modello, fornisce un file system semplice, scalabile, completamente gestito e condiviso da utilizzare con Amazon EKS.
+ [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) EKS) ti aiuta a eseguire Kubernetes su AWS senza dover installare o gestire i tuoi cluster.
+ [AWS Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html) è un motore di elaborazione serverless per Amazon EKS. Crea e gestisce risorse di calcolo per le tue applicazioni Kubernetes.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ti aiuta a creare e controllare chiavi crittografiche per proteggere i tuoi dati.
**Altri strumenti**
+ [Docker](https://www.docker.com/) è un insieme di prodotti Platform as a Service (PaaS) che utilizzano la virtualizzazione a livello di sistema operativo per fornire software in container.
+ [eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) è un'utilità da riga di comando per la creazione e la gestione di cluster Kubernetes su Amazon EKS.
+ [kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) è un'interfaccia a riga di comando che ti aiuta a eseguire comandi sui cluster Kubernetes.
+ [jq è uno strumento a riga di comando per l'analisi di JSON.](https://stedolan.github.io/jq/download/)
**Codice**
Il codice per questo pattern è fornito nella [configurazione di GitHub persistenza con Amazon EFS su Amazon EKS utilizzando il repository AWS Fargate](https://github.com/aws-samples/eks-efs-share-within-fargate). Gli script sono organizzati da epic, nelle cartelle `epic01` Through`epic06`, corrispondenti all'ordine nella sezione [Epics](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-epics) di questo schema.
## Best practice
L'architettura di destinazione include i seguenti servizi e componenti e segue le best practice di [AWS Well-Architected](https://aws.amazon.com/architecture/well-architected/) Framework:
+ Amazon EFS, che fornisce un file system NFS elastico semplice, scalabile e completamente gestito. Viene utilizzato come file system condiviso tra tutte le repliche dell'applicazione PoC in esecuzione nei pod, distribuiti nelle sottoreti private del cluster Amazon EKS scelto.
+ Una destinazione di montaggio Amazon EFS per ogni sottorete privata. Ciò fornisce ridondanza per zona di disponibilità all'interno del cloud privato virtuale (VPC) del cluster.
+ Amazon EKS, che esegue i carichi di lavoro Kubernetes. È necessario effettuare il provisioning di un cluster Amazon EKS prima di utilizzare questo modello, come descritto nella sezione [Prerequisiti](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-prereqs).
+ AWS KMS, che fornisce la crittografia a riposo per i contenuti archiviati nel file system Amazon EFS.
+ Fargate, che gestisce le risorse di elaborazione per i container in modo che tu possa concentrarti sui requisiti aziendali anziché sul carico dell'infrastruttura. Il profilo Fargate viene creato per tutte le sottoreti private. Fornisce ridondanza per zona di disponibilità all'interno del cloud privato virtuale (VPC) del cluster.
+ Kubernetes Pods, per verificare che i contenuti possano essere condivisi, consumati e scritti da diverse istanze di un'applicazione.
## Epiche
### Esegui il provisioning di un cluster Amazon EKS (opzionale)
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un cluster Amazon EKS. | Se hai già un cluster distribuito, passa alla prossima epopea. Crea un cluster Amazon EKS nel tuo account AWS esistente. Nella [GitHub directory](https://github.com/aws-samples/eks-efs-share-within-fargate/tree/master/bootstrap), utilizza uno dei modelli per distribuire un cluster Amazon EKS utilizzando Terraform o eksctl. Per ulteriori informazioni, consulta [Creazione di un cluster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) nella documentazione di Amazon EKS. Nel modello Terraform, ci sono anche esempi che mostrano come: collegare i profili Fargate al cluster Amazon EKS, creare un file system Amazon EFS e distribuire il driver CSI Amazon EFS nel cluster Amazon EKS. | Amministratore AWS, amministratore Terraform o eksctl, amministratore Kubernetes |
| Esporta variabili di ambiente. | Esegui lo script env.sh. Ciò fornisce le informazioni richieste nei passaggi successivi.source ./scripts/env.sh
Inform the AWS Account ID:
<13-digit-account-id>
Inform your AWS Region:
Inform your Amazon EKS Cluster Name:
Inform the Amazon EFS Creation Token:
Se non ancora indicato, puoi ottenere tutte le informazioni richieste sopra con i seguenti comandi CLI.# ACCOUNT ID
aws sts get-caller-identity --query "Account" --output text
# REGION CODE
aws configure get region
# CLUSTER EKS NAME
aws eks list-clusters --query "clusters" --output text
# GENERATE EFS TOKEN
uuidgen
| Amministratore di sistema AWS |
### Crea un namespace Kubernetes e un profilo Fargate collegato
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea uno spazio dei nomi Kubernetes e un profilo Fargate per i carichi di lavoro delle applicazioni. | Crea uno spazio dei nomi per ricevere i carichi di lavoro delle applicazioni che interagiscono con Amazon EFS. Eseguire lo script `create-k8s-ns-and-linked-fargate-profile.sh`. Puoi scegliere di utilizzare un nome di namespace personalizzato o lo spazio dei nomi fornito di default. `poc-efs-eks-fargate`**Con un nome di namespace dell'applicazione personalizzato:**export $APP_NAMESPACE=
./scripts/epic01/create-k8s-ns-and-linked-fargate-profile.sh \
-c "$CLUSTER_NAME" -n "$APP_NAMESPACE"
**Senza un nome di namespace dell'applicazione personalizzato:**./scripts/epic01/create-k8s-ns-and-linked-fargate-profile.sh \
-c "$CLUSTER_NAME"
`$CLUSTER_NAME`dov'è il nome del tuo cluster Amazon EKS. Il `-n ` parametro è facoltativo; se non viene informato, verrà fornito un nome di namespace generato di default. | Utente Kubernetes con autorizzazioni concesse |
### Creare un file system Amazon EFS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Genera un token unico. | Amazon EFS richiede un token di creazione per garantire un funzionamento idempotente (la chiamata all'operazione con lo stesso token di creazione non ha alcun effetto). Per soddisfare questo requisito, è necessario generare un token univoco utilizzando una tecnica disponibile. Ad esempio, è possibile generare un identificatore univoco universale (UUID) da utilizzare come token di creazione. | Amministratore di sistema AWS |
| Crea un file system Amazon EFS. | Crea il file system per ricevere i file di dati letti e scritti dai carichi di lavoro dell'applicazione. È possibile creare un file system crittografato o non crittografato. (Come procedura ottimale, il codice di questo modello crea un sistema crittografato per abilitare la crittografia a riposo per impostazione predefinita.) Puoi utilizzare una chiave AWS KMS unica e simmetrica per crittografare il tuo file system. Se non viene specificata una chiave personalizzata, viene utilizzata una chiave gestita AWS.Utilizza lo script create-efs.sh per creare un file system Amazon EFS crittografato o non crittografato, dopo aver generato un token univoco per Amazon EFS.**Con crittografia inattiva, senza chiave KMS:**./scripts/epic02/create-efs.sh \
-c "$CLUSTER_NAME" \
-t "$EFS_CREATION_TOKEN"
dove `$CLUSTER_NAME` è il nome del tuo cluster Amazon EKS ed `$EFS_CREATION_TOKEN` è un token di creazione univoco per il file system.**Con crittografia inattiva, con una chiave KMS:**./scripts/epic02/create-efs.sh \
-c "$CLUSTER_NAME" \
-t "$EFS_CREATION_TOKEN" \
-k "$KMS_KEY_ALIAS"
dove `$CLUSTER_NAME` è il nome del cluster Amazon EKS, `$EFS_CREATION_TOKEN` è un token di creazione univoco per il file system ed `$KMS_KEY_ALIAS` è l'alias per la chiave KMS.**Senza crittografia:**./scripts/epic02/create-efs.sh -d \
-c "$CLUSTER_NAME" \
-t "$EFS_CREATION_TOKEN"
dove `$CLUSTER_NAME` è il nome del tuo cluster Amazon EKS, `$EFS_CREATION_TOKEN` è un token di creazione univoco per il file system e `–d` disabilita la crittografia a riposo. | Amministratore di sistema AWS |
| Creare un gruppo di sicurezza. | Crea un gruppo di sicurezza per consentire al cluster Amazon EKS di accedere al file system Amazon EFS. | Amministratore di sistema AWS |
| Aggiorna la regola in entrata per il gruppo di sicurezza. | Aggiorna le regole in entrata del gruppo di sicurezza per consentire il traffico in entrata per le seguenti impostazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate.html) | Amministratore di sistema AWS |
| Aggiungi una destinazione di montaggio per ogni sottorete privata. | Per ogni sottorete privata del cluster Kubernetes, crea una destinazione di montaggio per il file system e il gruppo di sicurezza. | Amministratore di sistema AWS |
### Installa i componenti Amazon EFS nel cluster Kubernetes
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Implementa il driver CSI di Amazon EFS. | Implementa il driver CSI Amazon EFS nel cluster. Il driver effettua il provisioning dello storage in base alle dichiarazioni di volume persistenti create dalle applicazioni. Esegui lo `create-k8s-efs-csi-sc.sh` script per distribuire il driver CSI di Amazon EFS e la classe di storage nel cluster../scripts/epic03/create-k8s-efs-csi-sc.sh
Questo script utilizza l'`kubectl`utilità, quindi assicurati che il contesto sia stato configurato e punti al cluster Amazon EKS desiderato. | Utente Kubernetes con autorizzazioni concesse |
| Implementare la classe di archiviazione. | Implementa la classe di storage nel cluster per il provisioner Amazon EFS (efs.csi.aws.com). | Utente Kubernetes con autorizzazioni concesse |
### Installa l'applicazione PoC nel cluster Kubernetes
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Distribuisci il volume persistente. | Implementa il volume persistente e collegalo alla classe di storage creata e all'ID del file system Amazon EFS. L'applicazione utilizza il volume persistente per leggere e scrivere contenuti. È possibile specificare qualsiasi dimensione per il volume persistente nel campo di archiviazione. Kubernetes richiede questo campo, ma poiché Amazon EFS è un file system elastico, non impone alcuna capacità del file system. Puoi distribuire il volume persistente con o senza crittografia. (Il driver CSI di Amazon EFS abilita la crittografia per impostazione predefinita, come best practice.) Esegui lo `deploy-poc-app.sh` script per distribuire il volume persistente, l'attestazione del volume persistente e i due carichi di lavoro.**Con crittografia in transito:**./scripts/epic04/deploy-poc-app.sh \
-t "$EFS_CREATION_TOKEN"
`$EFS_CREATION_TOKEN`dov'è il token di creazione univoco per il file system.**Senza crittografia in transito:**./scripts/epic04/deploy-poc-app.sh -d \
-t "$EFS_CREATION_TOKEN"
dove `$EFS_CREATION_TOKEN` è il token di creazione univoco per il file system e `–d` disabilita la crittografia in transito. | Utente Kubernetes con autorizzazioni concesse |
| Implementa la dichiarazione di volume persistente richiesta dall'applicazione. | Implementate la dichiarazione di volume persistente richiesta dall'applicazione e collegatela alla classe di archiviazione. Utilizza la stessa modalità di accesso del volume persistente creato in precedenza. È possibile specificare qualsiasi dimensione per l'attestazione del volume persistente nel campo di archiviazione. Kubernetes richiede questo campo, ma poiché Amazon EFS è un file system elastico, non impone alcuna capacità del file system. | Utente Kubernetes con autorizzazioni concesse |
| Distribuisci il carico di lavoro 1. | Distribuisci il pod che rappresenta il carico di lavoro 1 dell'applicazione. Questo carico di lavoro scrive il contenuto nel file. `/data/out1.txt` | Utente Kubernetes con autorizzazioni concesse |
| Implementa il carico di lavoro 2. | Implementa il pod che rappresenta il carico di lavoro 2 dell'applicazione. Questo carico di lavoro scrive il contenuto nel file. `/data/out2.txt` | Utente Kubernetes con autorizzazioni concesse |
### Convalida la persistenza, la durabilità e la condivisibilità del file system
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Controlla lo stato di`PersistentVolume`. | Immettere il seguente comando per verificare lo stato di`PersistentVolume`.kubectl get pv
Per un esempio di output, vedere la sezione [Informazioni aggiuntive](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional). | Utente Kubernetes con autorizzazioni concesse |
| Controlla lo stato di. `PersistentVolumeClaim` | Immettere il seguente comando per verificare lo stato di`PersistentVolumeClaim`.kubectl -n poc-efs-eks-fargate get pvc
Per un esempio di output, vedere la sezione [Informazioni aggiuntive](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional). | Utente Kubernetes con autorizzazioni concesse |
| Verifica che il workload 1 possa scrivere sul file system. | Immetti il comando seguente per convalidare il carico di lavoro 1 su cui sta scrivendo. `/data/out1.txt`kubectl exec -ti poc-app1 -n poc-efs-eks-fargate -- tail -f /data/out1.txt
I risultati sono simili ai seguenti:...
Thu Sep 3 15:25:07 UTC 2023 - PoC APP 1
Thu Sep 3 15:25:12 UTC 2023 - PoC APP 1
Thu Sep 3 15:25:17 UTC 2023 - PoC APP 1
...
| Utente Kubernetes con autorizzazioni concesse |
| Verifica che Workload 2 sia in grado di scrivere sul file system. | Immetti il comando seguente per convalidare il workload 2 su cui sta scrivendo. `/data/out2.txt`kubectl -n $APP_NAMESPACE exec -ti poc-app2 -- tail -f /data/out2.txt
I risultati sono simili ai seguenti:...
Thu Sep 3 15:26:48 UTC 2023 - PoC APP 2
Thu Sep 3 15:26:53 UTC 2023 - PoC APP 2
Thu Sep 3 15:26:58 UTC 2023 - PoC APP 2
...
| Utente Kubernetes con autorizzazioni concesse |
| Verifica che il carico di lavoro 1 sia in grado di leggere il file scritto da workload 2. | Immetti il seguente comando per verificare che il carico di lavoro 1 sia in grado di leggere il `/data/out2.txt` file scritto dal carico di lavoro 2.kubectl exec -ti poc-app1 -n poc-efs-eks-fargate -- tail -n 3 /data/out2.txt
I risultati sono simili ai seguenti:...
Thu Sep 3 15:26:48 UTC 2023 - PoC APP 2
Thu Sep 3 15:26:53 UTC 2023 - PoC APP 2
Thu Sep 3 15:26:58 UTC 2023 - PoC APP 2
...
| Utente Kubernetes con autorizzazioni concesse |
| Verifica che il carico di lavoro 2 sia in grado di leggere il file scritto dal carico di lavoro 1. | Immetti il seguente comando per verificare che il carico di lavoro 2 sia in grado di leggere il `/data/out1.txt` file scritto dal carico di lavoro 1.kubectl -n $APP_NAMESPACE exec -ti poc-app2 -- tail -n 3 /data/out1.txt
I risultati sono simili ai seguenti:...
Thu Sep 3 15:29:22 UTC 2023 - PoC APP 1
Thu Sep 3 15:29:27 UTC 2023 - PoC APP 1
Thu Sep 3 15:29:32 UTC 2023 - PoC APP 1
...
| Utente Kubernetes con autorizzazioni concesse |
| Verifica che i file vengano conservati dopo aver rimosso i componenti dell'applicazione. | Successivamente, utilizzate uno script per rimuovere i componenti dell'applicazione (persistent volume, persistent volume claim e pods) e verificare che i file `/data/out2.txt` vengano conservati nel file `/data/out1.txt` system. Eseguire lo script `validate-efs-content.sh` utilizzando il comando seguente../scripts/epic05/validate-efs-content.sh \
-t "$EFS_CREATION_TOKEN"
`$EFS_CREATION_TOKEN`dov'è il token di creazione univoco per il file system.I risultati sono simili ai seguenti:pod/poc-app-validation created
Waiting for pod get Running state...
Waiting for pod get Running state...
Waiting for pod get Running state...
Results from execution of 'find /data' on validation process pod:
/data
/data/out2.txt
/data/out1.txt
| Utente Kubernetes con autorizzazioni concesse, amministratore di sistema |
### Monitora le operazioni
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Monitora i registri delle applicazioni. | Nell'ambito di un'operazione che dura il secondo giorno, spedisci i log delle applicazioni ad Amazon CloudWatch per il monitoraggio. | Amministratore di sistema AWS, utente Kubernetes con autorizzazioni concesse |
| Monitora i contenitori Amazon EKS e Kubernetes con Container Insights. | Nell'ambito di un'operazione del secondo giorno, monitora i sistemi Amazon EKS e Kubernetes utilizzando Amazon Container Insights. CloudWatch Questo strumento raccoglie, aggrega e riepiloga i parametri delle applicazioni containerizzate a diversi livelli e dimensioni. [Per ulteriori informazioni, consulta la sezione Risorse correlate.](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources) | Amministratore di sistema AWS, utente Kubernetes con autorizzazioni concesse |
| Monitora Amazon EFS con CloudWatch. | Nell'ambito di un'operazione del secondo giorno, monitora i file system utilizzando Amazon CloudWatch, che raccoglie ed elabora i dati grezzi da Amazon EFS in metriche leggibili quasi in tempo reale. [Per ulteriori informazioni, consulta la sezione Risorse correlate.](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources) | Amministratore di sistema AWS |
### Eseguire la pulizia delle risorse
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Pulisci tutte le risorse create per il pattern. | Dopo aver completato questo schema, pulisci tutte le risorse per evitare di incorrere in costi AWS. Esegui lo `clean-up-resources.sh` script per rimuovere tutte le risorse dopo aver finito di utilizzare l'applicazione PoC. Completate una delle seguenti opzioni.**Con crittografia inattiva, con una chiave KMS:**./scripts/epic06/clean-up-resources.sh \
-c "$CLUSTER_NAME" \
-t "$EFS_CREATION_TOKEN" \
-k "$KMS_KEY_ALIAS"
dove `$CLUSTER_NAME` è il nome del cluster Amazon EKS, `$EFS_CREATION_TOKEN` è il token di creazione per il file system ed `$KMS_KEY_ALIAS` è l'alias per la chiave KMS.**Senza crittografia a riposo:**./scripts/epic06/clean-up-resources.sh \
-c "$CLUSTER_NAME" \
-t "$EFS_CREATION_TOKEN"
dove `$CLUSTER_NAME` è il nome del cluster Amazon EKS ed `$EFS_CREATION_TOKEN` è il token di creazione per il file system. | Utente Kubernetes con autorizzazioni concesse, amministratore di sistema |
## Risorse correlate
**Riferimenti**
+ [AWS Fargate per Amazon EKS ora supporta Amazon EFS (annuncio](https://aws.amazon.com/blogs/aws/new-aws-fargate-for-amazon-eks-now-supports-amazon-efs/))
+ [Come acquisire i log delle applicazioni quando si utilizza Amazon EKS su AWS Fargate](https://aws.amazon.com/blogs/containers/how-to-capture-application-logs-when-using-amazon-eks-on-aws-fargate/) (post sul blog)
+ [Utilizzo di Container Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContainerInsights.html) ( CloudWatch documentazione Amazon)
+ [Configurazione di Container Insights su Amazon EKS e Kubernetes (documentazione Amazon)](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/deploy-container-insights-EKS.html) CloudWatch
+ [Metriche di Amazon EKS e Kubernetes Container Insights (documentazione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-metrics-EKS.html) Amazon) CloudWatch
+ [Monitoraggio di Amazon EFS con Amazon CloudWatch](https://docs.aws.amazon.com/efs/latest/ug/monitoring-cloudwatch.html) (documentazione Amazon EFS)
**GitHub tutorial ed esempi**
+ [Provisioning statico](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/static_provisioning/README.md)
+ [Crittografia in transito](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/encryption_in_transit/README.md)
+ [Accesso al file system da più pod](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/multiple_pods/README.md)
+ [Consumo di Amazon EFS in StatefulSets](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/statefulset/README.md)
+ [Montaggio dei sottopercorsi](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/volume_path/README.md)
+ [Utilizzo dei punti di accesso Amazon EFS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/access_points/README.md)
+ [Progetti Amazon EKS per Terraform](https://aws-ia.github.io/terraform-aws-eks-blueprints/)
**Strumenti necessari**
+ [Installazione della versione 2 dell'interfaccia a riga di comando di AWS](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html)
+ [Installazione di eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)
+ [Installare kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
+ [Installazione di jq](https://stedolan.github.io/jq/download/)
## Informazioni aggiuntive
Di seguito è riportato un esempio di output del `kubectl get pv` comando.
```
NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE
poc-app-pv 1Mi RWX Retain Bound poc-efs-eks-fargate/poc-app-pvc efs-sc 3m56s
```
Di seguito è riportato un esempio di output del `kubectl -n poc-efs-eks-fargate get pvc` comando.
```
NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE
poc-app-pvc Bound poc-app-pv 1Mi RWX efs-sc 4m34s
```
# Configura la scalabilità automatica basata sugli eventi in Amazon EKS utilizzando Amazon EKS Pod Identity e KEDA
*Dipen Desai, Abhay Diwan, Kamal Joshi e Mahendra Revanasiddappa, Amazon Web Services*
## Riepilogo
Le piattaforme di orchestrazione, come [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) EKS), hanno semplificato la gestione del ciclo di vita delle applicazioni basate su container. Questo aiuta le organizzazioni a concentrarsi sulla creazione, la protezione, il funzionamento e la manutenzione di applicazioni basate su contenitori. Man mano che le implementazioni basate sugli eventi diventano più comuni, le organizzazioni scalano sempre più spesso le implementazioni di Kubernetes in base a varie fonti di eventi. Questo metodo, combinato con la scalabilità automatica, può portare a significativi risparmi sui costi fornendo risorse di elaborazione su richiesta e una scalabilità efficiente adattata alla logica dell'applicazione.
[KEDA](https://keda.sh/) è un autoscaler basato su eventi basato su Kubernetes. KEDA ti aiuta a scalare qualsiasi contenitore in Kubernetes in base al numero di eventi che devono essere elaborati. È leggero e si integra con qualsiasi cluster Kubernetes. [Funziona anche con componenti Kubernetes standard, come Horizontal Pod Autoscaling (HPA).](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) Offre anche KEDA [TriggerAuthentication](https://keda.sh/docs/2.14/concepts/authentication/#re-use-credentials-and-delegate-auth-with-triggerauthentication), una funzionalità che consente di delegare l'autenticazione. Consente di descrivere i parametri di autenticazione separati dai contenitori ScaledObject e dai contenitori di distribuzione.
AWS fornisce ruoli AWS Identity and Access Management (IAM) che supportano diverse opzioni di implementazione di Kubernetes, tra cui Amazon EKS, Amazon EKS Anywhere Servizio Red Hat OpenShift su AWS (ROSA) e cluster Kubernetes autogestiti su Amazon Elastic Compute Cloud (Amazon). EC2 Questi ruoli utilizzano costrutti IAM, come i provider di identità OpenID Connect (OIDC) e le policy di fiducia IAM, per operare in ambienti diversi senza affidarsi direttamente ai servizi Amazon EKS o. APIs Per ulteriori informazioni, consulta [i ruoli IAM per gli account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) nella documentazione di Amazon EKS.
[Amazon EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html) semplifica il processo con cui gli account di servizio Kubernetes assumono ruoli IAM senza richiedere provider OIDC. Offre la possibilità di gestire le credenziali per le tue applicazioni. Invece di creare e distribuire AWS le tue credenziali ai contenitori o utilizzare il ruolo dell' EC2 istanza Amazon, associ un ruolo IAM a un account di servizio Kubernetes e configuri i tuoi Pods per utilizzare l'account di servizio. Questo ti aiuta a utilizzare un ruolo IAM su più cluster e semplifica la gestione delle policy abilitando il riutilizzo delle politiche di autorizzazione tra i ruoli IAM.
Implementando KEDA con Amazon EKS Pod Identity, le aziende possono ottenere una scalabilità automatica efficiente basata sugli eventi e una gestione semplificata delle credenziali. Le applicazioni si scalano in base alla domanda, il che ottimizza l'utilizzo delle risorse e riduce i costi.
Questo modello ti aiuta a integrare Amazon EKS Pod Identity con KEDA. Mostra come utilizzare l'account del `keda-operator` servizio e delegare l'autenticazione con. `TriggerAuthentication` Descrive inoltre come impostare una relazione di trust tra un ruolo IAM per l'operatore KEDA e un ruolo IAM per l'applicazione. Questa relazione di fiducia consente a KEDA di monitorare i messaggi nelle code degli eventi e di regolare il ridimensionamento per gli oggetti Kubernetes di destinazione.
## Prerequisiti e limitazioni
**Prerequisiti**
+ AWS Command Line Interface [(AWS CLI) versione 2.13.17 o successiva, installata](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Python versione 3.11.5 o successiva, installata](https://www.python.org/downloads/)
+ AWS SDK per Python (Boto3) [versione 1.34.135 o successiva, installata](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)
+ [Helm versione 3.12.3 o successiva, installata](https://helm.sh/docs/intro/install/)
+ [kubectl versione 1.25.1 o successiva, installata](https://kubernetes.io/docs/tasks/tools/)
+ [Docker Engine versione 26.1.1 o successiva, installata](https://docs.docker.com/engine/install/)
+ [Creazione di un cluster Amazon EKS versione 1.24 o successiva](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html)
+ [Prerequisiti per la creazione dell'agente Amazon EKS Pod Identity, soddisfatti](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-agent-setup.html#pod-id-agent-add-on-create)
**Limitazioni**
+ È necessario stabilire una relazione di fiducia tra il `keda-operator` ruolo e il `keda-identity` ruolo. Le istruzioni sono fornite nella sezione [Epics](#event-driven-auto-scaling-with-eks-pod-identity-and-keda-epics) di questo modello.
## Architecture
In questo modello, crei le seguenti AWS risorse:
+ Repository **Amazon Elastic Container Registry (Amazon ECR)**: in questo modello, questo repository viene denominato. `keda-pod-identity-registry` Questo repository privato viene utilizzato per archiviare le immagini Docker dell'applicazione di esempio.
+ Coda **Amazon Simple Queue Service (Amazon SQS)**: in questo modello, questa coda viene denominata. `event-messages-queue` La coda funge da buffer dei messaggi che raccoglie e archivia i messaggi in arrivo. KEDA monitora le metriche della coda, come il numero di messaggi o la lunghezza della coda, e ridimensiona automaticamente l'applicazione in base a queste metriche.
+ **Ruolo IAM per l'applicazione**: in questo modello, questo ruolo viene denominato. `keda-identity` Il `keda-operator` ruolo assume questo ruolo. Questo ruolo consente l'accesso alla coda di Amazon SQS.
+ **Ruolo IAM per l'operatore KEDA**: in questo modello, questo ruolo è denominato. `keda-operator` L'operatore KEDA utilizza questo ruolo per effettuare le chiamate AWS API richieste. Questo ruolo dispone delle autorizzazioni necessarie per assumerlo`keda-identity`. A causa della relazione di fiducia tra i ruoli `keda-operator` e i `keda-identity` ruoli, il `keda-operator` ruolo dispone delle autorizzazioni Amazon SQS.
Tramite le risorse personalizzate `TriggerAuthentication` e `ScaledObject` Kubernetes, l'operatore utilizza il `keda-identity` ruolo per connettersi a una coda Amazon SQS. In base alla dimensione della coda, KEDA ridimensiona automaticamente la distribuzione dell'applicazione. Aggiunge 1 pod ogni 5 messaggi non letti nella coda. Nella configurazione predefinita, se non ci sono messaggi non letti nella coda di Amazon SQS, l'applicazione viene ridimensionata fino a 0 pod. L'operatore KEDA monitora la coda a intervalli specificati dall'utente.
L'immagine seguente mostra come utilizzi Amazon EKS Pod Identity per fornire al `keda-operator` ruolo un accesso sicuro alla coda Amazon SQS.
![\[Utilizzo di KEDA e Amazon EKS Pod Identity per scalare automaticamente un'applicazione basata su Kubernetes.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/56f7506d-e8d3-43e5-bec6-42267fedd0ae/images/05bdbd09-9eb8-4c0b-8c0d-efe38aecb683.png)
Il diagramma mostra il flusso di lavoro seguente:
1. Installa l'agente Amazon EKS Pod Identity nel cluster Amazon EKS.
1. Implementa l'operatore KEDA nello spazio dei nomi KEDA nel cluster Amazon EKS.
1. Crei i ruoli `keda-operator` e `keda-identity` IAM nella destinazione. Account AWS
1. Stabilisci una relazione di fiducia tra i ruoli IAM.
1. L'applicazione viene distribuita nel `security` namespace.
1. L'operatore KEDA esegue il polling dei messaggi in una coda Amazon SQS.
1. KEDA avvia l'HPA, che ridimensiona automaticamente l'applicazione in base alla dimensione della coda.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Elastic Container Registry (Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile.
+ [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) EKS) ti aiuta a eseguire AWS Kubernetes senza dover installare o gestire il tuo piano di controllo o i tuoi nodi Kubernetes.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle.
+ [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)) fornisce una coda ospitata sicura, durevole e disponibile che ti aiuta a integrare e disaccoppiare sistemi e componenti software distribuiti.
**Altri strumenti**
+ [KEDA](https://keda.sh/) è un autoscaler basato su eventi basato su Kubernetes.
**Deposito di codice**
Il codice per questo pattern è disponibile nella [scalabilità GitHub automatica basata sugli eventi utilizzando EKS Pod Identity e](https://github.com/aws-samples/event-driven-autoscaling-using-podidentity-and-keda/tree/main) il repository KEDA.
## Best practice
Consigliamo di seguire queste best practices:
+ [Best practice di Amazon EKS](https://docs.aws.amazon.com/eks/latest/best-practices/introduction.html)
+ [Best practice per la sicurezza in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)
+ [Best practice di Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-best-practices.html)
## Epiche
### Crea risorse AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea il ruolo IAM per l'operatore KEDA. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | Amministratore AWS |
| Crea il ruolo IAM per l'applicazione di esempio. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | Amministratore AWS |
| Creare una coda Amazon SQS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | Informazioni generali su AWS |
| Crea un repository Amazon ECR. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | Informazioni generali su AWS |
### Configura il cluster Amazon EKS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Implementa l'agente Amazon EKS Pod Identity. | Per il cluster Amazon EKS di destinazione, configura l'agente Amazon EKS Pod Identity. Segui le istruzioni in [Configurare Amazon EKS Pod Identity Agent](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-agent-setup.html#pod-id-agent-add-on-create) nella documentazione di Amazon EKS. | AWS DevOps |
| Implementa KEDA. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | DevOps ingegnere |
| Assegna il ruolo IAM all'account del servizio Kubernetes. | Segui le istruzioni in [Assegnare un ruolo IAM a un account di servizio Kubernetes nella](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html) documentazione di Amazon EKS. Utilizzare i seguenti valori:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | AWS DevOps |
| Crea uno spazio dei nomi . | Immetti il seguente comando per creare uno spazio `security` dei nomi nel cluster Amazon EKS di destinazione:kubectl create ns security
| DevOps ingegnere |
### Distribuzione di un'applicazione di esempio
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare i file dell'applicazione. | Inserisci il seguente comando per clonare l'[auto scaling basato sugli eventi utilizzando EKS Pod Identity e](https://github.com/aws-samples/event-driven-autoscaling-using-podidentity-and-keda/tree/main) il repository KEDA da: GitHubgit clone https://github.com/aws-samples/event-driven-autoscaling-using-podidentity-and-keda.git
| DevOps ingegnere |
| Creazione dell'immagine Docker. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | DevOps ingegnere |
| Invia l'immagine Docker ad Amazon ECR. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html)Puoi trovare i comandi push accedendo alla pagina del repository Amazon ECR e scegliendo **Visualizza** comandi push. | DevOps ingegnere |
| Implementare un’applicazione di esempio. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | DevOps ingegnere |
| Assegna il ruolo IAM all'account del servizio applicativo. | Effettua una delle seguenti operazioni per associare il ruolo `keda-identity` IAM all'account di servizio per l'applicazione di esempio:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | DevOps ingegnere |
| Implementa `ScaledObject` e. `TriggerAuthentication` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | DevOps ingegnere |
### Prova il ridimensionamento automatico
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Invia messaggi alla coda di Amazon SQS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | DevOps ingegnere |
| Monitora i pod delle applicazioni. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) | DevOps ingegnere |
## risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| L'operatore KEDA non è in grado di scalare l'applicazione. | Immettete il seguente comando per controllare i log del ruolo `keda-operator` IAM:kubectl logs -n keda -l app=keda-operator -c keda-operator
Se è presente un codice di `HTTP 403` risposta, l'applicazione e lo scaler KEDA non dispongono di autorizzazioni sufficienti per accedere alla coda di Amazon SQS. Completa questa procedura:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html)Se si `Assume-Role` verifica un errore, un [ruolo IAM del nodo Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html) non è in grado di assumere il ruolo IAM per cui è stato definito`TriggerAuthentication`. Completa questa procedura:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/event-driven-auto-scaling-with-eks-pod-identity-and-keda.html) |
## Risorse correlate
+ [Configurare Amazon EKS Pod Identity Agent](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-agent-setup.html) (documentazione Amazon EKS)
+ [Implementazione di KEDA (documentazione](https://keda.sh/docs/2.14/deploy/) KEDA)
+ [ScaledObject specifiche (documentazione KEDA](https://keda.sh/docs/2.16/reference/scaledobject-spec/))
+ [Autenticazione con TriggerAuthentication](https://keda.sh/docs/2.14/concepts/authentication/) (documentazione KEDA)
# Semplifica le implementazioni di PostgreSQL su Amazon EKS utilizzando PGO
*Shalaka Dengale, Amazon Web Services*
## Riepilogo
Questo modello integra Postgres Operator di Crunchy Data (PGO) con Amazon Elastic Kubernetes Service (Amazon EKS) per semplificare le implementazioni di PostgreSQL in ambienti nativi del cloud. PGO offre automazione e scalabilità per la gestione dei database PostgreSQL in Kubernetes. Combinando PGO con Amazon EKS, si forma una solida piattaforma per la distribuzione, la gestione e la scalabilità efficiente dei database PostgreSQL.
Questa integrazione offre i seguenti vantaggi chiave:
+ Distribuzione automatizzata: semplifica l'implementazione e la gestione dei cluster PostgreSQL.
+ Definizioni di risorse personalizzate (CRDs):**** utilizza le primitive Kubernetes per la gestione di PostgreSQL.
+ Alta disponibilità: supporta il failover automatico e la replica sincrona.
+ Backup e ripristini automatizzati:**** semplifica i processi di backup e ripristino.
+ Scalabilità orizzontale:**** consente il ridimensionamento dinamico dei cluster PostgreSQL.
+ Aggiornamenti di versione: facilita gli aggiornamenti continui con tempi di inattività minimi.
+ Sicurezza: applica la crittografia, i controlli di accesso e i meccanismi di autenticazione.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS.
+ [AWS Command Line Interface (AWS CLI) versione](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html) 2, installata e configurata su Linux, macOS o Windows.
+ [AWS CLI Config](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html), per connettere AWS le risorse dalla riga di comando.
+ [eksctl](https://github.com/eksctl-io/eksctl#installation), installato e configurato su Linux, macOS o Windows.
+ `kubectl`, installato e configurato per accedere alle risorse sul tuo cluster Amazon EKS. Per ulteriori informazioni, consulta [Configurare kubectl ed eksctl nella documentazione di Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html).
+ Il terminale del tuo computer è configurato per accedere al cluster Amazon EKS. Per ulteriori informazioni, consulta [Configurare il computer per comunicare con il cluster](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html#eks-configure-kubectl) nella documentazione di Amazon EKS.
**Versioni del prodotto**
+ [Versioni di Kubernetes 1.21—1.24 o successive (consulta la documentazione di PGO).](https://access.crunchydata.com/documentation/postgres-operator/5.2.5/)
+ PostgreSQL versione 10 o successiva. Questo modello utilizza PostgreSQL versione 16.
**Limitazioni**
+ Alcuni Servizi AWS non sono disponibili in tutti. Regioni AWS Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
## Architecture
**Stack tecnologico Target**
+ Amazon EKS
+ Amazon Virtual Private Cloud (Amazon VPC) (Amazon VPC)
+ Amazon Elastic Compute Cloud (Amazon EC2)
**Architettura di destinazione**
![\[Architettura per l'utilizzo di PGO con tre zone di disponibilità e due repliche e PgBouncer operatore PGO.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/4c164012-7527-4ebe-b6a7-c129600328d6/images/26a5572b-405b-4634-b96a-91254c3ea2c1.png)
Questo modello crea un'architettura che contiene un cluster Amazon EKS con tre nodi. Ogni nodo viene eseguito su un set di istanze EC2 nel backend. Questa configurazione di PostgreSQL segue un'architettura di replica primaria, particolarmente efficace per i casi d'uso ad alta intensità di lettura. L'architettura include i seguenti componenti:
+ Il **contenitore del database primario (pg-primary)** ospita l'istanza PostgreSQL principale in cui sono dirette tutte le operazioni di scrittura.
+ **I contenitori di replica secondari (pg-replica) ospitano** le istanze PostgreSQL che replicano i dati dal database primario e gestiscono le operazioni di lettura.
+ **PgBouncer**è un pool di connessioni leggero per database PostgreSQL incluso in PGO. Si colloca tra il client e il server PostgreSQL e funge da intermediario per le connessioni al database.
+ **PGO** automatizza l'implementazione e la gestione dei cluster PostgreSQL in questo ambiente Kubernetes.
+ **Patroni** è uno strumento open source che gestisce e automatizza le configurazioni ad alta disponibilità per PostgreSQL. È incluso in PGO. Quando usi Patroni con PGO in Kubernetes, svolge un ruolo cruciale nel garantire la resilienza e la tolleranza ai guasti di un cluster PostgreSQL. [Per ulteriori informazioni, consulta la documentazione di Patroni.](https://patroni.readthedocs.io/en/latest/)
Il flusso di lavoro include i seguenti passaggi:
+ **Implementa l'operatore PGO**. Implementa l'operatore PGO sul tuo cluster Kubernetes eseguito su Amazon EKS. Questo può essere fatto utilizzando i manifesti di Kubernetes o i grafici Helm. Questo modello utilizza i manifesti di Kubernetes.
+ **Definisci le istanze PostgreSQL**. Quando l'operatore è in esecuzione, si creano risorse personalizzate (CRs) per specificare lo stato desiderato delle istanze PostgreSQL. Ciò include configurazioni come archiviazione, replica e impostazioni di alta disponibilità.
+ **Gestione degli operatori**. Interagisci con l'operatore tramite oggetti API Kubernetes, ad esempio CRs per creare, aggiornare o eliminare istanze PostgreSQL.
+ **Monitoraggio e manutenzione.** Puoi monitorare lo stato e le prestazioni delle istanze PostgreSQL in esecuzione su Amazon EKS. Gli operatori spesso forniscono metriche e registrazioni per scopi di monitoraggio. Se necessario, è possibile eseguire attività di manutenzione di routine come aggiornamenti e patch. Per ulteriori informazioni, consulta [Monitoraggio delle prestazioni del cluster e visualizzazione dei log](https://docs.aws.amazon.com/eks/latest/userguide/eks-observe.html) nella documentazione di Amazon EKS.
+ **Scalabilità e backup**: è possibile utilizzare le funzionalità fornite dall'operatore per ridimensionare le istanze PostgreSQL e gestire i backup.
Questo modello non copre le operazioni di monitoraggio, manutenzione e backup.
**Automazione e scalabilità**
+ È possibile utilizzare CloudFormation per automatizzare la creazione dell'infrastruttura. Per ulteriori informazioni, consulta [Creare risorse Amazon EKS CloudFormation](https://docs.aws.amazon.com/eks/latest/userguide/creating-resources-with-cloudformation.html) nella documentazione di Amazon EKS.
+ Puoi utilizzare GitVersion o Jenkins build Numbers per automatizzare la distribuzione delle istanze di database.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Elastic Kubernetes Service (Amazon EKS) ti aiuta a eseguire Kubernetes](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) su AWS Kubernetes senza dover installare o gestire il tuo piano di controllo o i tuoi nodi Kubernetes.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che ti aiuta a interagire tramite comandi nella shell della riga di comando. Servizi AWS
**Altri strumenti**
+ [eksctl](https://eksctl.io/) è un semplice strumento da riga di comando per la creazione di cluster su Amazon EKS.
+ [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) è un'utilità da riga di comando per eseguire comandi su cluster Kubernetes.
+ [PGO](https://github.com/CrunchyData/postgres-operator) automatizza e ridimensiona la gestione dei database PostgreSQL in Kubernetes.
## Best practice
Segui queste best practice per garantire un'implementazione fluida ed efficiente:
+ **Proteggi il tuo cluster EKS**. Implementa le migliori pratiche di sicurezza per il tuo cluster EKS, come l'utilizzo di ruoli AWS Identity and Access Management (IAM) per account di servizio (IRSA), policy di rete e gruppi di sicurezza VPC. Limita l'accesso al server API del cluster EKS e crittografa le comunicazioni tra i nodi e il server API utilizzando TLS.
+ **Garantisci la compatibilità delle versioni** tra PGO e Kubernetes in esecuzione su Amazon EKS. Alcune funzionalità di PGO potrebbero richiedere versioni specifiche di Kubernetes o introdurre limitazioni di compatibilità. Per ulteriori informazioni, consulta [Componenti e compatibilità](https://access.crunchydata.com/documentation/postgres-operator/5.2.5/references/components/) nella documentazione di PGO.
+ **Pianifica l'allocazione delle risorse** per la tua implementazione PGO, tra cui CPU, memoria e archiviazione. Considera i requisiti di risorse sia di PGO che delle istanze PostgreSQL che gestisce. Monitora l'utilizzo delle risorse e ridimensiona le risorse in base alle esigenze.
+ **Progettato per un'elevata disponibilità**. Progetta la tua implementazione PGO per un'elevata disponibilità per ridurre al minimo i tempi di inattività e garantire l'affidabilità. Implementa più repliche di PGO su più zone di disponibilità per la tolleranza agli errori.
+ **Implementa procedure di backup e ripristino** per i database PostgreSQL gestiti da PGO. Utilizza le funzionalità fornite da PGO o soluzioni di backup di terze parti compatibili con Kubernetes e Amazon EKS.
+ **Configura il monitoraggio e la registrazione per la** tua implementazione PGO per tenere traccia delle prestazioni, dello stato e degli eventi. Utilizza strumenti come Prometheus per il monitoraggio delle metriche e Grafana per la visualizzazione. Configura la registrazione per acquisire i registri PGO per la risoluzione dei problemi e il controllo.
+ **Configura correttamente la rete** per consentire le comunicazioni tra PGO, istanze PostgreSQL e altri servizi nel tuo cluster Kubernetes. Utilizza le funzionalità di rete Amazon VPC e i plug-in di rete Kubernetes come Calico o Amazon [VPC](https://github.com/aws/amazon-vpc-cni-k8s) CNI per l'applicazione delle politiche di rete e l'isolamento del traffico.
+ **Scegli le opzioni di storage appropriate** per i tuoi database PostgreSQL, considerando fattori quali prestazioni, durabilità e scalabilità. Usa volumi Amazon Elastic Block Store (Amazon EBS) AWS o servizi di storage gestito per lo storage persistente. Per ulteriori informazioni, consulta [Archivia volumi Kubernetes con Amazon EBS nella documentazione di Amazon](https://docs.aws.amazon.com/eks/latest/userguide/ebs-csi.html) EKS.
+ **Utilizza strumenti Infrastructure as Code (IaC)** CloudFormation per automatizzare la distribuzione e la configurazione di PGO su Amazon EKS. Definisci i componenti dell'infrastruttura, tra cui il cluster EKS, il networking e le risorse PGO, come codice per garantire coerenza, ripetibilità e controllo delle versioni.
## Epiche
### Creazione di un ruolo IAM
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un ruolo IAM. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html) | Amministratore AWS |
### Crea un cluster Amazon EKS.
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un cluster Amazon EKS. | Se hai già distribuito un cluster, salta questo passaggio. Altrimenti, distribuisci un cluster Amazon EKS nel tuo ambiente attuale Account AWS utilizzando `eksctl` Terraform o. CloudFormation Questo modello viene utilizzato `eksctl` per la distribuzione in cluster.Questo modello utilizza Amazon EC2 come gruppo di nodi per Amazon EKS. Se desideri utilizzarlo AWS Fargate, consulta la `managedNodeGroups` configurazione nella documentazione di [eksctl](https://eksctl.io/usage/schema/#managedNodeGroups).[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html) | Amministratore AWS, amministratore Terraform o eksctl, amministratore Kubernetes |
| Convalida lo stato del cluster. | Esegui il comando seguente per visualizzare lo stato corrente dei nodi nel cluster:kubectl get nodes
Se riscontri errori, consulta la [sezione sulla risoluzione dei problemi](https://docs.aws.amazon.com/eks/latest/userguide/troubleshooting.html) della documentazione di Amazon EKS. | Amministratore AWS, amministratore Terraform o eksctl, amministratore Kubernetes |
### Crea un provider di identità OIDC
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Abilita il provider IAM OIDC. | Come prerequisito per il driver Amazon EBS Container Storage Interface (CSI), devi disporre di un provider IAM OpenID Connect (OIDC) esistente per il tuo cluster.Abilita il provider IAM OIDC utilizzando il seguente comando:eksctl utils associate-iam-oidc-provider --region={region} --cluster={YourClusterNameHere} --approvePer ulteriori informazioni su questo passaggio, consulta la [documentazione di Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/ebs-csi.html). | Amministratore AWS |
| Crea un ruolo IAM per il driver CSI di Amazon EBS. | Usa il seguente `eksctl` comando per creare il ruolo IAM per il driver CSI:eksctl create iamserviceaccount \
--region {RegionName} \
--name ebs-csi-controller-sa \
--namespace kube-system \
--cluster {YourClusterNameHere} \
--attach-policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
--approve \
--role-only \
--role-name AmazonEKS_EBS_CSI_DriverRole
Se utilizzi unità Amazon EBS crittografate, devi configurare ulteriormente la policy. Per istruzioni, consulta la [documentazione del driver Amazon EBS SCI](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md#installation-1). | Amministratore AWS |
| Aggiungi il driver Amazon EBS CSI. | Usa il seguente `eksctl` comando per aggiungere il driver Amazon EBS CSI:eksctl create addon \
--name aws-ebs-csi-driver \
--cluster service-account-role-arn arn:aws:iam::$(aws sts get-caller-identity \
--query Account \
--output text):role/AmazonEKS_EBS_CSI_DriverRole \
--force
| Amministratore AWS |
### Installa PGO
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona il repository PGO. | Clona il repository per PGO GitHub :git clone https://github.com/CrunchyData/postgres-operator-examples.git
| AWS DevOps |
| Fornisci i dettagli del ruolo per la creazione dell'account di servizio. | Per concedere al cluster Amazon EKS l'accesso alle AWS risorse richieste, specifica l'Amazon Resource Name (ARN) del ruolo OIDC che hai creato in precedenza nel `service_account.yaml` file in cui si trova. [GitHub](https://github.com/CrunchyData/postgres-operator/blob/main/config/rbac/cluster/service_account.yaml)cd postgres-operator-examples
---
metadata:
annotations:
eks.amazonaws.com/role-arn: arn:aws:iam:::role/ # Update the OIDC role ARN created earlier
| Amministratore AWS, amministratore Kubernetes |
| Crea il namespace e i prerequisiti PGO. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html) | Amministratore Kubernetes |
| Verifica la creazione dei pod. | Verifica che lo spazio dei nomi e la configurazione predefinita siano stati creati:kubectl get pods -n postgres-operator
| Amministratore AWS, amministratore Kubernetes |
| Verifica. PVCs | Utilizzate il seguente comando per verificare le dichiarazioni di volume persistenti (PVCs):kubectl describe pvc -n postgres-operator
| Amministratore AWS, amministratore Kubernetes |
### Crea e distribuisci un operatore
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un operatore. | Modifica il contenuto del file che si trova in `/kustomize/postgres/postgres.yaml` modo che corrisponda a quanto segue:spec:
instances:
- name: pg-1
replicas: 3
patroni:
dynamicConfiguration:
postgresql:
pg_hba:
- "host all all 0.0.0.0/0 trust" # this line enabled logical replication with programmatic access
- "host all postgres 127.0.0.1/32 md5"
synchronous_mode: true
users:
- name: replicator
databases:
- testdb
options: "REPLICATION"
Questi aggiornamenti eseguono le seguenti operazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html) | Amministratore AWS, DBA, amministratore Kubernetes |
| Implementa l'operatore. | Implementa l'operatore PGO per consentire la gestione e il funzionamento semplificati dei database PostgreSQL negli ambienti Kubernetes:kubectl apply -k kustomize/postgres
| Amministratore AWS, DBA, amministratore Kubernetes |
| Verifica la distribuzione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html)Dall'output del comando, annota la replica principale (`primary_pod_name`) e leggi replica (`read_pod_name`). Li utilizzerai nei passaggi successivi. | Amministratore AWS, DBA, amministratore Kubernetes |
### Verifica la replica in streaming
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Scrive i dati sulla replica principale. | Usa i seguenti comandi per connetterti alla replica primaria di PostgreSQL e scrivere dati nel database:kubectl exec -it bash -n postgres-operator
psql
CREATE TABLE customers (firstname text, customer_id serial, date_created timestamp);
\dt
| Amministratore AWS, amministratore Kubernetes |
| Verifica che la replica letta contenga gli stessi dati. | Connect alla replica di lettura PostgreSQL e verifica se la replica in streaming funziona correttamente:kubectl exec -it {read_pod_name} bash -n postgres-operatorpsql
\dt
La replica di lettura dovrebbe contenere la tabella creata nella replica primaria nel passaggio precedente. | Amministratore AWS, amministratore Kubernetes |
## Risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| Il pod non si avvia. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html) |
| Le repliche sono notevolmente inferiori rispetto al database principale. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html) |
| Non hai visibilità sulle prestazioni e sullo stato del cluster PostgreSQL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html) |
| La replica non funziona. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/streamline-postgresql-deployments-amazon-eks-pgo.html) |
## Risorse correlate
+ [Amazon Elastic Kubernetes](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/amazon-elastic-kubernetes-service.html) Service *(white paper sulla panoramica delle opzioni di distribuzione* su AWS)
+ [CloudFormation](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/aws-cloudformation.html)(*Panoramica delle opzioni di distribuzione nel white paper di AWS*)
+ [Inizia a usare Amazon EKS — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) (*Amazon EKS User Guide*)
+ [Configura kubectl ed eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) (Guida per l'utente di *Amazon EKS*)
+ [Creare un ruolo per la federazione OpenID Connect](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html) (*IAM User Guide*)
+ [Configurazione delle impostazioni per la AWS CLI(Guida per l'AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)*utente*)
+ [Documentazione di Crunchy Postgres per Kubernetes](https://access.crunchydata.com/documentation/postgres-operator/latest)
+ [Crunch & Learn: Crunchy](https://www.youtube-nocookie.com/embed/IIf9WZO3K50) Postgres per Kubernetes 5.0 (video)
# Semplifica l'autenticazione delle applicazioni con TLS reciproco in Amazon ECS utilizzando Application Load Balancer
*Olawale Olaleye e Shamanth Devagari, Amazon Web Services*
## Riepilogo
Questo modello ti aiuta a semplificare l'autenticazione delle applicazioni e ad alleggerire gli oneri di sicurezza con il TLS reciproco in Amazon Elastic Container Service (Amazon ECS) [utilizzando Application Load](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/mutual-authentication.html) Balancer (ALB). Con ALB, puoi autenticare i certificati client X.509 da. AWS Autorità di certificazione privata Questa potente combinazione aiuta a garantire una comunicazione sicura tra i servizi, riducendo la necessità di complessi meccanismi di autenticazione all'interno delle applicazioni. Inoltre, il modello utilizza Amazon Elastic Container Registry (Amazon ECR) per archiviare le immagini dei container.
L'esempio di questo modello utilizza immagini Docker da una galleria pubblica per creare inizialmente i carichi di lavoro di esempio. Successivamente, vengono create nuove immagini Docker per essere archiviate in Amazon ECR. Per la fonte, prendi in considerazione un sistema basato su Git come GitHub, o Bitbucket GitLab, oppure usa Amazon Simple Storage Service Amazon S3 (Amazon S3). Per creare le immagini Docker, valuta la possibilità di utilizzarle per le immagini successive. AWS CodeBuild
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS con accesso agli stack di distribuzione. AWS CloudFormation Assicurati di disporre delle [autorizzazioni utente o di ruolo AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/control-access-with-iam.html) (IAM) per la distribuzione. CloudFormation
+ AWS Command Line Interface [(AWS CLI) installato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) [Configurate](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) AWS le credenziali sul computer locale o nell'ambiente utilizzando AWS CLI o impostando le variabili di ambiente nel `~/.aws/credentials` file.
+ [OpenSSL](https://www.openssl.org/) installato.
+ [Docker installato.](https://www.docker.com/get-started/)
+ [Familiarità con quanto Servizi AWS descritto in Strumenti.](#simplify-application-authentication-with-mutual-tls-in-amazon-ecs-tools)
+ Conoscenza di Docker e NGINX.
**Limitazioni**
+ Mutual TLS for Application Load Balancer supporta solo i certificati client X.509v3. I certificati client X.509v1 non sono supportati.
+ Il CloudFormation modello fornito nell'archivio di codice di questo pattern non include il provisioning di un CodeBuild progetto come parte dello stack.
+ Alcuni Servizi AWS non sono disponibili in tutti. Regioni AWS Per la disponibilità regionale, vedi [AWS Servizi per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta [Endpoints and quotas del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
**Versioni del prodotto**
+ Docker versione 27.3.1 o successiva
+ AWS CLI versione 2.14.5 o successiva
## Architecture
Il diagramma seguente mostra i componenti dell'architettura di questo modello.
![\[Flusso di lavoro per l'autenticazione con TLS reciproco utilizzando Application Load Balancer.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/a343fa4e-097f-416b-9c83-01a28eb57dc3/images/e1371297-b987-4487-9b13-8120933c921f.png)
Il diagramma mostra il flusso di lavoro seguente:
1. Crea un repository Git ed esegui il commit del codice dell'applicazione nel repository.
1. Crea un'autorità di certificazione (CA) privata in. AWS Private CA
1. Crea un CodeBuild progetto. CodeBuildproject Viene attivato dalle modifiche di commit, crea l'immagine Docker e pubblica l'immagine creata su Amazon ECR.
1. Copia la catena di certificati e l'ente del certificato dalla CA e carica il pacchetto di certificati su Amazon S3.
1. Crea un trust store con il pacchetto CA che hai caricato su Amazon S3. Associate il trust store ai listener TLS reciproci sull'Application Load Balancer (ALB).
1. Utilizza la CA privata per emettere certificati client per i carichi di lavoro dei container. Crea anche un certificato TLS privato utilizzando. AWS Private CA
1. Importa il certificato TLS privato in AWS Certificate Manager (ACM) e usalo con ALB.
1. Il carico di lavoro del container in `ServiceTwo` utilizza il certificato client emesso per autenticarsi con l'ALB quando comunica con il carico di lavoro del contenitore in. `ServiceOne`
1. Il carico di lavoro del container in `ServiceOne` utilizza il certificato client emesso per autenticarsi con l'ALB quando comunica con il carico di lavoro del contenitore in. `ServiceTwo`
**Automazione e scalabilità**
Questo modello può essere completamente automatizzato utilizzando CloudFormation o AWS Cloud Development Kit (AWS CDK) eseguendo operazioni API da un SDK per fornire le AWS risorse.
Puoi utilizzarla AWS CodePipeline per implementare una pipeline di integrazione e distribuzione continua (CI/CD) CodeBuild per automatizzare il processo di creazione di immagini dei container e distribuire nuove versioni ai servizi del cluster Amazon ECS.
## Tools (Strumenti)
**Servizi AWS **
+ [AWS Certificate Manager (ACM)](https://docs.aws.amazon.com/acm/latest/userguide/acm-overview.html) ti aiuta a creare, archiviare e rinnovare certificati e chiavi SSL/TLS X.509 pubblici e privati che proteggono i tuoi siti Web e le tue applicazioni. AWS
+ [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ti aiuta a configurare AWS le risorse, fornirle in modo rapido e coerente e gestirle durante tutto il loro ciclo di vita tra e. Account AWS Regioni AWS
+ [AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)è un servizio di compilazione completamente gestito che consente di compilare codice sorgente, eseguire test unitari e produrre artefatti pronti per l'implementazione.
+ [Amazon Elastic Container Registry (Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile.
+ [Amazon Elastic Container Service (Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html)) è un servizio di gestione dei container veloce e altamente scalabile per l'esecuzione, l'arresto e la gestione dei container su un cluster. Puoi eseguire le tue attività e i tuoi servizi su un'infrastruttura serverless gestita da. AWS Fargate In alternativa, per un maggiore controllo sulla tua infrastruttura, puoi eseguire attività e servizi su un cluster di istanze Amazon Elastic Compute Cloud (Amazon EC2) che gestisci.
+ [Amazon ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html) ti consente di interagire direttamente con i container senza dover prima interagire con il sistema operativo del contenitore host, aprire le porte in entrata o gestire le chiavi SSH. Puoi usare ECS Exec per eseguire comandi in o inserire una shell in un contenitore in esecuzione su un' EC2 istanza Amazon o su. AWS Fargate
+ [Elastic Load Balancing (ELB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) distribuisce il traffico di applicazioni o di rete in entrata su più destinazioni. Ad esempio, puoi distribuire il traffico tra EC2 istanze Amazon, contenitori e indirizzi IP, in una o più zone di disponibilità. ELB monitora lo stato dei target registrati e indirizza il traffico solo verso gli obiettivi integri. ELB ridimensiona il sistema di bilanciamento del carico in base alle variazioni del traffico in entrata nel tempo. Può adattarsi automaticamente alla maggior parte dei carichi di lavoro.
+ [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/userguide/what-is-fargate.html)ti aiuta a eseguire contenitori senza dover gestire server o EC2 istanze Amazon. Fargate è compatibile sia con Amazon ECS che con Amazon Elastic Kubernetes Service (Amazon EKS). Puoi eseguire le tue attività e i tuoi servizi Amazon ECS con il tipo di lancio Fargate o con un provider di capacità Fargate. A tale scopo, impacchetta l'applicazione in contenitori, specifica i requisiti di CPU e memoria, definisci le politiche di rete e IAM e avvia l'applicazione. Ogni attività Fargate ha il proprio limite di isolamento e non condivide il kernel sottostante, le risorse della CPU, le risorse di memoria o l'interfaccia elastica di rete con un'altra attività.
+ [AWS Autorità di certificazione privata](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html)consente la creazione di gerarchie di autorità di certificazione (CA) private, tra cui root e subordinate CAs, senza i costi di investimento e manutenzione legati alla gestione di una CA locale.
**Altri strumenti******
+ [Docker](https://www.docker.com/) è un insieme di prodotti Platform as a Service (PaaS) che utilizzano la virtualizzazione a livello di sistema operativo per fornire software in container.
+ [GitHub[GitLab](https://docs.gitlab.com/ee/user/get_started/get_started_projects.html)](https://docs.github.com/en/repositories/creating-and-managing-repositories/quickstart-for-repositories), e [Bitbucket](https://support.atlassian.com/bitbucket-cloud/docs/tutorial-learn-bitbucket-with-git/) sono alcuni dei sistemi di controllo del codice sorgente basati su Git comunemente usati per tenere traccia delle modifiche al codice sorgente.
+ [NGINX Open Source è un sistema open source](https://nginx.org/en/docs/?_ga=2.187509224.1322712425.1699399865-405102969.1699399865) di bilanciamento del carico, cache dei contenuti e server web. Questo modello lo utilizza come server web.
+ [OpenSSL](https://www.openssl.org/) è una libreria open source che fornisce servizi utilizzati dalle implementazioni OpenSSL di TLS e CMS.
**Archivio di codici**
Il codice per questo pattern è disponibile nel repository GitHub [MTLS-with-Application-Load-Balancer-in-Amazon-ECS](https://github.com/aws-samples/mTLS-with-Application-Load-Balancer-in-Amazon-ECS).
## Best practice
+ Usa Amazon ECS Exec per eseguire comandi o inserire una shell in un contenitore in esecuzione su Fargate. Puoi anche usare ECS Exec per raccogliere informazioni diagnostiche per il debug.
+ Utilizza i gruppi di sicurezza e gli elenchi di controllo degli accessi alla rete (ACLs) per controllare il traffico in entrata e in uscita tra i servizi. Le attività Fargate ricevono un indirizzo IP dalla sottorete configurata nel cloud privato virtuale (VPC).
## Epiche
### Crea il repository
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Scarica il codice sorgente. | Per scaricare il codice sorgente di questo pattern, esegui il fork o clona il repository GitHub [MTLS-with-Application-Load-Balancer-in-Amazon-ECS](https://github.com/aws-samples/mTLS-with-Application-Load-Balancer-in-Amazon-ECS). | DevOps ingegnere |
| Crea un repository Git. | Per creare un repository Git che contenga il Dockerfile e `buildspec.yaml` i file, usa i seguenti passaggi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/simplify-application-authentication-with-mutual-tls-in-amazon-ecs.html)`git clone https://github.com/aws-samples/mTLS-with-Application-Load-Balancer-in-Amazon-ECS.git` | DevOps ingegnere |
### Crea CA e genera certificati
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea una CA privata in AWS Private CA. | Per creare un'autorità di certificazione (CA) privata, esegui i seguenti comandi nel tuo terminale. Sostituite i valori nelle variabili di esempio con i vostri valori. export AWS_DEFAULT_REGION="us-west-2"
export SERVICES_DOMAIN="www.example.com"
export ROOT_CA_ARN=`aws acm-pca create-certificate-authority \
--certificate-authority-type ROOT \
--certificate-authority-configuration \
"KeyAlgorithm=RSA_2048,
SigningAlgorithm=SHA256WITHRSA,
Subject={
Country=US,
State=WA,
Locality=Seattle,
Organization=Build on AWS,
OrganizationalUnit=mTLS Amazon ECS and ALB Example,
CommonName=${SERVICES_DOMAIN}}" \
--query CertificateAuthorityArn --output text`
Per maggiori dettagli, consulta [Creare una CA privata AWS Private CA nella](https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html) AWS documentazione. | DevOps ingegnere, AWS DevOps |
| Crea e installa il tuo certificato CA privato. | Per creare e installare un certificato per la tua CA root privata, esegui i seguenti comandi nel tuo terminale:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/simplify-application-authentication-with-mutual-tls-in-amazon-ecs.html) | AWS DevOps, DevOps ingegnere |
| Richiedi un certificato gestito. | Per richiedere un certificato privato AWS Certificate Manager da utilizzare con il tuo ALB privato, usa il seguente comando:export TLS_CERTIFICATE_ARN=`aws acm request-certificate \
--domain-name "*.${DOMAIN_DOMAIN}" \
--certificate-authority-arn ${ROOT_CA_ARN} \
--query CertificateArn --output text`
| DevOps ingegnere, AWS DevOps |
| Utilizza la CA privata per emettere un certificato client. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/simplify-application-authentication-with-mutual-tls-in-amazon-ecs.html)`openssl req -out client_csr1.pem -new -newkey rsa:2048 -nodes -keyout client_private-key1.pem``openssl req -out client_csr2.pem -new -newkey rsa:2048 -nodes -keyout client_private-key2.pem`Questo comando restituisce la CSR e la chiave privata per i due servizi. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/simplify-application-authentication-with-mutual-tls-in-amazon-ecs.html)SERVICE_ONE_CERT_ARN=`aws acm-pca issue-certificate \
--certificate-authority-arn ${ROOT_CA_ARN} \
--csr fileb://client_csr1.pem \
--signing-algorithm "SHA256WITHRSA" \
--validity Value=5,Type="YEARS" --query CertificateArn --output text`
echo "SERVICE_ONE_CERT_ARN: ${SERVICE_ONE_CERT_ARN}"
aws acm-pca get-certificate \
--certificate-authority-arn ${ROOT_CA_ARN} \
--certificate-arn ${SERVICE_ONE_CERT_ARN} \
| jq -r '.Certificate' > client_cert1.cert
SERVICE_TWO_CERT_ARN=`aws acm-pca issue-certificate \
--certificate-authority-arn ${ROOT_CA_ARN} \
--csr fileb://client_csr2.pem \
--signing-algorithm "SHA256WITHRSA" \
--validity Value=5,Type="YEARS" --query CertificateArn --output text`
echo "SERVICE_TWO_CERT_ARN: ${SERVICE_TWO_CERT_ARN}"
aws acm-pca get-certificate \
--certificate-authority-arn ${ROOT_CA_ARN} \
--certificate-arn ${SERVICE_TWO_CERT_ARN} \
| jq -r '.Certificate' > client_cert2.cert
Per ulteriori informazioni, consulta [Emettere certificati privati per entità finali](https://docs.aws.amazon.com/privateca/latest/userguide/PcaIssueCert.html) nella AWS documentazione. | DevOps ingegnere, AWS DevOps |
### Fornitura di servizi AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Fornitura Servizi AWS con il CloudFormation modello. | Per effettuare il provisioning del cloud privato virtuale (VPC), del cluster Amazon ECS, dei servizi Amazon ECS, Application Load Balancer e Amazon Elastic Container Registry (Amazon ECR), utilizza il modello. CloudFormation | DevOps ingegnere |
| Ottieni variabili. | Verifica di avere un cluster Amazon ECS con due servizi in esecuzione. Per recuperare i dettagli delle risorse e memorizzarli come variabili, usa i seguenti comandi:
export LoadBalancerDNS=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`LoadBalancerDNS`].OutputValue')
export ECRRepositoryUri=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`ECRRepositoryUri`].OutputValue')
export ECRRepositoryServiceOneUri=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`ECRRepositoryServiceOneUri`].OutputValue')
export ECRRepositoryServiceTwoUri=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`ECRRepositoryServiceTwoUri`].OutputValue')
export ClusterName=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`ClusterName`].OutputValue')
export BucketName=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`BucketName`].OutputValue')
export Service1ListenerArn=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`Service1ListenerArn`].OutputValue')
export Service2ListenerArn=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`Service2ListenerArn`].OutputValue')
| DevOps ingegnere |
| Crea un CodeBuild progetto. | Per utilizzare un CodeBuild progetto per creare le immagini Docker per i tuoi servizi Amazon ECS, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/simplify-application-authentication-with-mutual-tls-in-amazon-ecs.html)Per maggiori dettagli, consulta [Creare un progetto di compilazione AWS CodeBuild nella](https://docs.aws.amazon.com/codebuild/latest/userguide/create-project.html) AWS documentazione. | AWS DevOps, DevOps ingegnere |
| Crea le immagini Docker. | È possibile utilizzare CodeBuild per eseguire il processo di creazione dell'immagine. CodeBuild necessita delle autorizzazioni per interagire con Amazon ECR e lavorare con Amazon S3.Come parte del processo, l'immagine Docker viene creata e inserita nel registro Amazon ECR. [Per dettagli sul modello e sul codice, consulta Informazioni aggiuntive.](#simplify-application-authentication-with-mutual-tls-in-amazon-ecs-additional)(Facoltativo) Per creare localmente a scopo di test, utilizzate il seguente comando:# login to ECR
aws ecr get-login-password | docker login --username AWS --password-stdin $ECRRepositoryUri
# build image for service one
cd /service1
aws s3 cp s3://$BucketName/serviceone/ service1/ --recursive
docker build -t $ECRRepositoryServiceOneUri .
docker push $ECRRepositoryServiceOneUri
# build image for service two
cd ../service2
aws s3 cp s3://$BucketName/servicetwo/ service2/ --recursive
docker build -t $ECRRepositoryServiceTwoUri .
docker push $ECRRepositoryServiceTwoUri
| DevOps ingegnere |
### Abilita il TLS reciproco
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Carica il certificato CA su Amazon S3. | Per caricare il certificato CA nel bucket Amazon S3, usa il seguente comando di esempio:`aws s3 cp ca-cert.pem s3://$BucketName/acm-trust-store/ ` | AWS DevOps, DevOps ingegnere |
| Crea il trust store. | Per creare il trust store, usa il seguente comando di esempio:TrustStoreArn=`aws elbv2 create-trust-store --name acm-pca-trust-certs \
--ca-certificates-bundle-s3-bucket $BucketName \
--ca-certificates-bundle-s3-key acm-trust-store/ca-cert.pem --query 'TrustStores[].TrustStoreArn' --output text`
| AWS DevOps, DevOps ingegnere |
| Carica i certificati dei clienti. | Per caricare certificati client su Amazon S3 per immagini Docker, usa il seguente comando di esempio:# for service one
aws s3 cp client_cert1.cert s3://$BucketName/serviceone/
aws s3 cp client_private-key1.pem s3://$BucketName/serviceone/
# for service two
aws s3 cp client_cert2.cert s3://$BucketName/servicetwo/
aws s3 cp client_private-key2.pem s3://$BucketName/servicetwo/
| AWS DevOps, DevOps ingegnere |
| Modifica l'ascoltatore. | Per abilitare il TLS reciproco sull'ALB, modifica i listener HTTPS utilizzando i seguenti comandi:aws elbv2 modify-listener \
--listener-arn $Service1ListenerArn \
--certificates CertificateArn=$TLS_CERTIFICATE_ARN_TWO \
--ssl-policy ELBSecurityPolicy-2016-08 \
--protocol HTTPS \
--port 8080 \
--mutual-authentication Mode=verify,TrustStoreArn=$TrustStoreArn,IgnoreClientCertificateExpiry=false
aws elbv2 modify-listener \
--listener-arn $Service2ListenerArn \
--certificates CertificateArn=$TLS_CERTIFICATE_ARN_TWO \
--ssl-policy ELBSecurityPolicy-2016-08 \
--protocol HTTPS \
--port 8090 \
--mutual-authentication Mode=verify,TrustStoreArn=$TrustStoreArn,IgnoreClientCertificateExpiry=false
Per ulteriori informazioni, consulta [Configurazione del TLS reciproco su un Application Load](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/configuring-mtls-with-elb.html) Balancer nella documentazione. AWS | AWS DevOps, DevOps ingegnere |
### Aggiorna i servizi
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aggiorna la definizione delle attività di Amazon ECS. | Per aggiornare la definizione del task di Amazon ECS, modifica il `image` parametro nella nuova revisione.Per ottenere i valori per i rispettivi servizi, aggiorna le definizioni delle attività con il nuovo Uri delle immagini Docker che hai creato nei passaggi precedenti: oppure `echo $ECRRepositoryServiceOneUri` `echo $ECRRepositoryServiceTwoUri`
"containerDefinitions": [
{
"name": "nginx",
"image": "public.ecr.aws/nginx/nginx:latest", # <----- change to new Uri
"cpu": 0,
Per ulteriori informazioni, consulta la sezione [Aggiornamento di una definizione di attività Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-task-definition-console-v2.html) utilizzando la console nella AWS documentazione. | AWS DevOps, DevOps ingegnere |
| Aggiorna il servizio Amazon ECS. | Aggiorna il servizio con la definizione di attività più recente. Questa definizione di attività è il modello per le immagini Docker di nuova creazione e contiene il certificato client richiesto per l'autenticazione TLS reciproca. Per aggiornare il servizio, utilizzare la seguente procedura:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/simplify-application-authentication-with-mutual-tls-in-amazon-ecs.html)Ripeti i passaggi per l'altro servizio. | Amministratore AWS, AWS DevOps, DevOps ingegnere |
### Accedi all'applicazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Copia l'URL dell'applicazione. | Usa la console Amazon ECS per visualizzare l'attività. Quando lo stato dell'attività è stato aggiornato a In **esecuzione**, seleziona l'attività. Nella sezione **Attività**, copia l'ID dell'attività. | Amministratore AWS, AWS DevOps |
| Testa la tua applicazione. | Per testare l'applicazione, usa ECS Exec per accedere alle attività.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/simplify-application-authentication-with-mutual-tls-in-amazon-ecs.html) | Amministratore AWS, AWS DevOps |
## Risorse correlate
**Documentazione Amazon ECS**
+ [Creazione di una definizione di attività Amazon ECS utilizzando la console](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html)
+ [Creazione di un’immagine di container da utilizzare su Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-container-image.html)
+ [Cluster Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html)
+ [Amazon ECS per AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-container-image.html#create-container-image-next-steps)
+ [Best practice di rete di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/networking-best-practices.html)
+ [Parametri di definizione del servizio Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service_definition_parameters.html)
**Altre risorse AWS **
+ [Come posso usare una CA AWS privata per configurare gli MTL sull'Application Load Balancer?](https://repost.aws/knowledge-center/elb-alb-configure-private-ca-mtls) ()AWS re:Post
## Informazioni aggiuntive
**Modifica del Dockerfile******
Il codice seguente mostra i comandi modificati nel Dockerfile per il servizio 1:
```
FROM public.ecr.aws/nginx/nginx:latest
WORKDIR /usr/share/nginx/html
RUN echo "Returning response from Service 1: Ok" > /usr/share/nginx/html/index.html
ADD client_cert1.cert client_private-key1.pem /usr/local/share/ca-certificates/
RUN chmod -R 400 /usr/local/share/ca-certificates/
```
Il codice seguente mostra i comandi modificati nel Dockerfile per il servizio 2:
```
FROM public.ecr.aws/nginx/nginx:latest
WORKDIR /usr/share/nginx/html
RUN echo "Returning response from Service 2: Ok" > /usr/share/nginx/html/index.html
ADD client_cert2.cert client_private-key2.pem /usr/local/share/ca-certificates/
RUN chmod -R 400 /usr/local/share/ca-certificates/
```
Se stai creando le immagini Docker con CodeBuild, il `buildspec` file utilizza il numero di CodeBuild build per identificare in modo univoco le versioni delle immagini come valore del tag. Puoi modificare il `buildspec` file in base alle tue esigenze, come mostrato nel seguente codice `buildspec ` personalizzato:
```
version: 0.2
phases:
pre_build:
commands:
- echo Logging in to Amazon ECR...
- aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $ECR_REPOSITORY_URI
- COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
- IMAGE_TAG=${COMMIT_HASH:=latest}
build:
commands:
# change the S3 path depending on the service
- aws s3 cp s3://$YOUR_S3_BUCKET_NAME/serviceone/ $CodeBuild_SRC_DIR/ --recursive
- echo Build started on `date`
- echo Building the Docker image...
- docker build -t $ECR_REPOSITORY_URI:latest .
- docker tag $ECR_REPOSITORY_URI:latest $ECR_REPOSITORY_URI:$IMAGE_TAG
post_build:
commands:
- echo Build completed on `date`
- echo Pushing the Docker images...
- docker push $ECR_REPOSITORY_URI:latest
- docker push $ECR_REPOSITORY_URI:$IMAGE_TAG
- echo Writing image definitions file...
# for ECS deployment reference
- printf '[{"name":"%s","imageUri":"%s"}]' $CONTAINER_NAME $ECR_REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
files:
- imagedefinitions.json
```
# Altri modelli
**Topics**
+ [Eliminazione automatica degli AWS CloudFormation stack e delle risorse associate](automate-deletion-cloudformation-stacks-associated-resources.md)
+ [Automatizza la gestione dinamica delle pipeline per l'implementazione di soluzioni hotfix in ambienti Gitflow utilizzando e AWS Service Catalog AWS CodePipeline](automate-dynamic-pipeline-management-for-deploying-hotfix-solutions.md)
+ [Crea automaticamente CI/CD pipeline e cluster Amazon ECS per microservizi utilizzando AWS CDK](automatically-build-ci-cd-pipelines-and-amazon-ecs-clusters-for-microservices-using-aws-cdk.md)
+ [Crea e invia immagini Docker ad Amazon ECR utilizzando GitHub Actions e Terraform](build-and-push-docker-images-to-amazon-ecr-using-github-actions-and-terraform.md)
+ [Containerizza i carichi di lavoro mainframe che sono stati modernizzati da Blu Age](containerize-mainframe-workloads-that-have-been-modernized-by-blu-age.md)
+ [Crea un parser di log personalizzato per Amazon ECS utilizzando un router di log Firelens](create-a-custom-log-parser-for-amazon-ecs-using-a-firelens-log-router.md)
+ [Implementa sistemi agentici su Amazon Bedrock con il framework CrewAI utilizzando Terraform](deploy-agentic-systems-on-amazon-bedrock-with-the-crewai-framework.md)
+ [Implementa un ambiente per applicazioni Blu Age containerizzate utilizzando Terraform](deploy-an-environment-for-containerized-blu-age-applications-by-using-terraform.md)
+ [Implementa la logica di preelaborazione in un modello ML in un singolo endpoint utilizzando una pipeline di inferenza in Amazon SageMaker](deploy-preprocessing-logic-into-an-ml-model-in-a-single-endpoint-using-an-inference-pipeline-in-amazon-sagemaker.md)
+ [Distribuisci carichi di lavoro dalle DevOps pipeline di Azure ai cluster Amazon EKS privati](deploy-workloads-from-azure-devops-pipelines-to-private-amazon-eks-clusters.md)
+ [Implementa la diagnostica e la risoluzione dei problemi di Kubernetes basate sull'intelligenza artificiale con K8SGPT e l'integrazione con Amazon Bedrock](implement-ai-powered-kubernetes-diagnostics-and-troubleshooting-with-k8sgpt-and-amazon-bedrock-integration.md)
+ [Gestisci le blue/green distribuzioni di microservizi su più account e regioni utilizzando i servizi di codice AWS e le chiavi multiregionali AWS KMS](manage-blue-green-deployments-of-microservices-to-multiple-accounts-and-regions-by-using-aws-code-services-and-aws-kms-multi-region-keys.md)
+ [Gestisci le applicazioni container locali configurando Amazon ECS Anywhere con AWS CDK](manage-on-premises-container-applications-by-setting-up-amazon-ecs-anywhere-with-the-aws-cdk.md)
+ [Esegui la migrazione da Oracle WebLogic ad Apache Tomcat (ToMee) su Amazon ECS](migrate-from-oracle-weblogic-to-apache-tomcat-tomee-on-amazon-ecs.md)
+ [Modernizza le applicazioni ASP.NET Web Forms su AWS](modernize-asp-net-web-forms-applications-on-aws.md)
+ [Monitora i repository Amazon ECR per le autorizzazioni wildcard utilizzando AWS e AWS Config CloudFormation](monitor-amazon-ecr-repositories-for-wildcard-permissions-using-aws-cloudformation-and-aws-config.md)
+ [Monitora l'attività delle applicazioni utilizzando CloudWatch Logs Insights](monitor-application-activity-by-using-cloudwatch-logs-insights.md)
+ [Configura una CI/CD pipeline per carichi di lavoro ibridi su Amazon ECS Anywhere utilizzando AWS CDK e GitLab](set-up-a-ci-cd-pipeline-for-hybrid-workloads-on-amazon-ecs-anywhere-by-using-aws-cdk-and-gitlab.md)
+ [Configura end-to-end la crittografia per le applicazioni su Amazon EKS utilizzando cert-manager e Let's Encrypt](set-up-end-to-end-encryption-for-applications-on-amazon-eks-using-cert-manager-and-let-s-encrypt.md)
+ [Semplifica la distribuzione di applicazioni multi-tenant Amazon EKS utilizzando Flux](simplify-amazon-eks-multi-tenant-application-deployment-by-using-flux.md)
+ [Semplifica i flussi di lavoro di machine learning dallo sviluppo locale agli esperimenti scalabili utilizzando SageMaker AI e Hydra](streamline-machine-learning-workflows-by-using-amazon-sagemaker.md)
+ [Struttura un progetto Python in architettura esagonale utilizzando AWS Lambda](structure-a-python-project-in-hexagonal-architecture-using-aws-lambda.md)
+ [AWS Infrastruttura di test utilizzando LocalStack e Terraform Tests](test-aws-infra-localstack-terraform.md)
+ [Coordina la dipendenza dalle risorse e l'esecuzione delle attività utilizzando il costrutto AWS Fargate WaitCondition hook](use-the-aws-fargate-waitcondition-hook-construct.md)
+ [Usa gli agenti Amazon Bedrock per automatizzare la creazione di controlli di accesso in Amazon EKS tramite istruzioni basate su testo](using-amazon-bedrock-agents-to-automate-creation-of-access-entry-controls-in-amazon-eks.md)