Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di Amazon MWAA con Amazon EKS
L'esempio seguente dimostra come utilizzare Amazon Managed Workflows per Apache Airflow con Amazon EKS.
**Topics**
+ [Versione](#mwaa-eks-example-version)
+ [Prerequisiti](#eksctl-prereqs)
+ [Crea una chiave pubblica per Amazon EC2](#eksctl-create-key)
+ [Creazione del cluster](#create-cluster-eksctl)
+ [Crea un namespace `mwaa`](#eksctl-namespace)
+ [Crea un ruolo per il namespace `mwaa`](#eksctl-role)
+ [Crea e collega un ruolo IAM per il cluster Amazon EKS](#eksctl-iam-role)
+ [Crea il file requirements.txt](#eksctl-requirements)
+ [Crea una mappatura delle identità per Amazon EKS](#eksctl-identity-map)
+ [Creazione del `kubeconfig`](#eksctl-kube-config)
+ [Create un DAG](#eksctl-create-dag)
+ [Aggiungi il DAG e `kube_config.yaml` al bucket Amazon S3](#eksctl-dag-bucket)
+ [Abilita e attiva l'esempio](#eksctl-trigger-pod)
## Versione
**[È possibile utilizzare l'esempio di codice in questa pagina con **Apache Airflow v2 in Python 3.10 e Apache Airflow v3**[in Python 3.11](https://peps.python.org/pep-0619/).](https://peps.python.org/pep-0664/)**
## Prerequisiti
Per utilizzare l'esempio in questo argomento, è necessario quanto segue:
+ Un ambiente [Amazon MWAA](get-started.md).
+ eksctl. Per ulteriori informazioni, consulta [Installare](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html#install-eksctl) eksctl.
+ kubectl. Per saperne di più, consulta [Installa e configura](https://kubernetes.io/docs/tasks/tools/install-kubectl/) kubectl. In alcuni casi questo viene installato con eksctl.
+ Una coppia di chiavi EC2 nella regione in cui crei il tuo ambiente Amazon MWAA. Per ulteriori informazioni, consulta [Creazione o importazione di una coppia di key pair](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#prepare-key-pair).
**Nota**
Quando si utilizza un `eksctl` comando, è possibile includere un `--profile` per specificare un profilo diverso da quello predefinito.
## Crea una chiave pubblica per Amazon EC2
Usa il seguente comando per creare una chiave pubblica dalla tua coppia di chiavi private.
```
ssh-keygen -y -f myprivatekey.pem > mypublickey.pub
```
Per maggiori informazioni, consulta [Recupero della chiave pubblica per la tua coppia di chiavi](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#retrieving-the-public-key).
## Creazione del cluster
Usa il comando seguente per creare il cluster. Se desideri un nome personalizzato per il cluster o crearlo in una regione diversa, sostituisci i valori del nome e della regione. È necessario creare il cluster nella stessa regione in cui si crea l'ambiente Amazon MWAA. Sostituisci i valori delle sottoreti in modo che corrispondano alle sottoreti della tua rete Amazon VPC che usi per Amazon MWAA. Sostituisci il valore in modo che corrisponda alla `ssh-public-key` chiave che usi. Puoi utilizzare una chiave esistente di Amazon EC2 che si trova nella stessa regione o creare una nuova chiave nella stessa regione in cui crei il tuo ambiente Amazon MWAA.
```
eksctl create cluster \
--name mwaa-eks \
--region us-west-2 \
--version 1.18 \
--nodegroup-name linux-nodes \
--nodes 3 \
--nodes-min 1 \
--nodes-max 4 \
--with-oidc \
--ssh-access \
--ssh-public-key MyPublicKey \
--managed \
--vpc-public-subnets "subnet-11111111111111111, subnet-2222222222222222222" \
--vpc-private-subnets "subnet-33333333333333333, subnet-44444444444444444"
```
Il completamento della creazione del cluster richiede del tempo. Una volta completata, puoi verificare che il cluster sia stato creato correttamente e che il provider IAM OIDC sia configurato utilizzando il seguente comando:
```
eksctl utils associate-iam-oidc-provider \
--region us-west-2 \
--cluster mwaa-eks \
--approve
```
## Crea un namespace `mwaa`
Dopo aver verificato che il cluster è stato creato correttamente, utilizzate il seguente comando per creare uno spazio dei nomi per i pod.
```
kubectl create namespace mwaa
```
## Crea un ruolo per il namespace `mwaa`
Dopo aver creato lo spazio dei nomi, crea un ruolo e un'associazione di ruoli per un utente Amazon MWAA su EKS che può eseguire pod in uno spazio dei nomi MWAA. Se hai usato un nome diverso per lo spazio dei nomi, sostituisci mwaa con il nome che hai usato. `-n mwaa`
```
cat << EOF | kubectl apply -f - -n mwaa
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: mwaa-role
rules:
- apiGroups:
- ""
- "apps"
- "batch"
- "extensions"
resources:
- "jobs"
- "pods"
- "pods/attach"
- "pods/exec"
- "pods/log"
- "pods/portforward"
- "secrets"
- "services"
verbs:
- "create"
- "delete"
- "describe"
- "get"
- "list"
- "patch"
- "update"
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: mwaa-role-binding
subjects:
- kind: User
name: mwaa-service
roleRef:
kind: Role
name: mwaa-role
apiGroup: rbac.authorization.k8s.io
EOF
```
Verifica che il nuovo ruolo possa accedere al cluster Amazon EKS eseguendo il comando seguente. Assicurati di utilizzare il nome corretto se non hai usato*mwaa*:
```
kubectl get pods -n mwaa --as mwaa-service
```
Viene restituito un messaggio che dice:
```
No resources found in mwaa namespace.
```
## Crea e collega un ruolo IAM per il cluster Amazon EKS
È necessario creare un ruolo IAM e quindi associarlo al cluster Amazon EKS (k8s) in modo che possa essere utilizzato per l'autenticazione tramite IAM. Il ruolo viene utilizzato solo per accedere al cluster e non dispone di autorizzazioni per la console o le chiamate API.
Crea un nuovo ruolo per l'ambiente Amazon MWAA utilizzando i passaggi seguenti. [Ruolo di esecuzione di Amazon MWAA](mwaa-create-role.md) Tuttavia, anziché creare e allegare le politiche descritte in quell'argomento, allega la seguente politica:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "airflow:PublishMetrics",
"Resource": "arn:aws:airflow:us-east-1:111122223333:environment/${MWAA_ENV_NAME}"
},
{
"Effect": "Deny",
"Action": "s3:ListAllMyBuckets",
"Resource": [
"arn:aws:s3:::{MWAA_S3_BUCKET}",
"arn:aws:s3:::{MWAA_S3_BUCKET}/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject*",
"s3:GetBucket*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::{MWAA_S3_BUCKET}",
"arn:aws:s3:::{MWAA_S3_BUCKET}/*"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:PutLogEvents",
"logs:GetLogEvents",
"logs:GetLogRecord",
"logs:GetLogGroupFields",
"logs:GetQueryResults",
"logs:DescribeLogGroups"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:airflow-${MWAA_ENV_NAME}-*"
]
},
{
"Effect": "Allow",
"Action": "cloudwatch:PutMetricData",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"sqs:ChangeMessageVisibility",
"sqs:DeleteMessage",
"sqs:GetQueueAttributes",
"sqs:GetQueueUrl",
"sqs:ReceiveMessage",
"sqs:SendMessage"
],
"Resource": "arn:aws:sqs:us-east-1:*:airflow-celery-*"
},
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:DescribeKey",
"kms:GenerateDataKey*",
"kms:Encrypt"
],
"NotResource": "arn:aws:kms:*:111122223333:key/*",
"Condition": {
"StringLike": {
"kms:ViaService": [
"sqs.us-east-1.amazonaws.com"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster"
],
"Resource": "arn:aws:eks:us-east-1:111122223333:cluster/${EKS_CLUSTER_NAME}"
}
]
}
```
------
Dopo aver creato il ruolo, modifica l'ambiente Amazon MWAA per utilizzare il ruolo creato come ruolo di esecuzione per l'ambiente. Per modificare il ruolo, modifica l'ambiente da utilizzare. È possibile selezionare il ruolo di esecuzione in **Autorizzazioni**.
**Problemi noti:**
+ Esiste un problema noto relativo al ruolo ARNs con i subpath che non sono in grado di autenticarsi con Amazon EKS. La soluzione alternativa consiste nel creare il ruolo di servizio manualmente anziché utilizzare quello creato dallo stesso Amazon MWAA. Per saperne di più, consulta [Ruoli con percorsi non funzionano quando il percorso è incluso nel loro ARN nella configmap di aws-auth](https://github.com/kubernetes-sigs/aws-iam-authenticator/issues/268)
+ Se l'elenco dei servizi Amazon MWAA non è disponibile in IAM, devi scegliere una politica di servizio alternativa, come Amazon EC2, e quindi aggiornare la politica di fiducia del ruolo in modo che corrisponda a quanto segue:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"airflow-env.amazonaws.com",
"airflow.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Per ulteriori informazioni, consulta [Come utilizzare le politiche di fiducia con i ruoli](https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/) IAM.
## Crea il file requirements.txt
Per utilizzare il codice di esempio in questa sezione, assicurati di aver aggiunto una delle seguenti opzioni di database al tuo`requirements.txt`. Per ulteriori informazioni, consulta[Installazione delle dipendenze in Python](working-dags-dependencies.md).
```
kubernetes
apache-airflow[cncf.kubernetes]==3.0.0
```
## Crea una mappatura delle identità per Amazon EKS
Usa l'ARN per il ruolo che hai creato nel seguente comando per creare una mappatura delle identità per Amazon EKS. Cambia la regione nella *us-east-1* regione in cui hai creato l'ambiente. Sostituisci l'ARN per il ruolo e, infine, sostituiscilo *mwaa-execution-role* con il ruolo di esecuzione del tuo ambiente.
```
eksctl create iamidentitymapping \
--region us-east-1 \
--cluster mwaa-eks \
--arn arn:aws:iam::123456789012:role/mwaa-execution-role \
--username mwaa-service
```
## Creazione del `kubeconfig`
Utilizzate il seguente comando per creare: `kubeconfig`
```
aws eks update-kubeconfig \
--region us-west-2 \
--kubeconfig ./kube_config.yaml \
--name mwaa-eks \
--alias aws
```
Se hai utilizzato un profilo specifico durante l'esecuzione, `update-kubeconfig` devi rimuovere la `env:` sezione aggiunta al file kube\$1config.yaml in modo che funzioni correttamente con Amazon MWAA. A tale scopo, elimina quanto segue dal file e poi salvalo:
```
env:
- name: AWS_PROFILE
value: profile_name
```
## Create un DAG
Usa il seguente esempio di codice per creare un file Python, ad esempio `mwaa_pod_example.py` per il DAG.
```
"""
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
from airflow import DAG
from datetime import datetime
from airflow.providers.cncf.kubernetes.operators.kubernetes_pod import KubernetesPodOperator
default_args = {
'owner': 'aws',
'depends_on_past': False,
'start_date': datetime(2019, 2, 20),
'provide_context': True
}
dag = DAG(
'kubernetes_pod_example', default_args=default_args, schedule_interval=None)
#use a kube_config stored in s3 dags folder for now
kube_config_path = '/usr/local/airflow/dags/kube_config.yaml'
podRun = KubernetesPodOperator(
namespace="mwaa",
image="ubuntu:18.04",
cmds=["bash"],
arguments=["-c", "ls"],
labels={"foo": "bar"},
name="mwaa-pod-test",
task_id="pod-task",
get_logs=True,
dag=dag,
is_delete_operator_pod=False,
config_file=kube_config_path,
in_cluster=False,
cluster_context='aws'
)
```
## Aggiungi il DAG e `kube_config.yaml` al bucket Amazon S3
Inserisci il DAG che hai creato e il `kube_config.yaml` file nel bucket Amazon S3 per l'ambiente Amazon MWAA. Puoi inserire file nel tuo bucket utilizzando la console Amazon S3 o il. AWS Command Line Interface
## Abilita e attiva l'esempio
In Apache Airflow, abilita l'esempio e poi attivalo.
Dopo che è stato eseguito e completato correttamente, utilizzate il seguente comando per verificare il pod:
```
kubectl get pods -n mwaa
```
Otterrete un risultato simile al seguente:
```
NAME READY STATUS RESTARTS AGE
mwaa-pod-test-aa11bb22cc3344445555666677778888 0/1 Completed 0 2m23s
```
È quindi possibile verificare l'output del pod con il seguente comando. Sostituisci il valore del nome con il valore restituito dal comando precedente:
```
kubectl logs -n mwaa mwaa-pod-test-aa11bb22cc3344445555666677778888
```