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à.
# Guida introduttiva a AWS App Mesh Kubernetes
**Importante**
Avviso di fine del supporto: il 30 settembre 2026, AWS verrà interrotto il supporto per. AWS App Mesh Dopo il 30 settembre 2026, non sarà più possibile accedere alla AWS App Mesh console o alle risorse. AWS App Mesh Per ulteriori informazioni, consulta questo post di blog [Migrazione AWS App Mesh da Amazon ECS Service Connect.](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect)
Quando esegui l'integrazione AWS App Mesh con Kubernetes utilizzando il controller App Mesh per Kubernetes, gestisci le risorse App Mesh, come mesh, servizi virtuali, nodi virtuali, router virtuali e percorsi tramite Kubernetes. Inoltre, aggiungi automaticamente le immagini del contenitore del sidecar App Mesh alle specifiche del pod Kubernetes. Questo tutorial ti guida attraverso l'installazione del controller App Mesh per Kubernetes per abilitare questa integrazione.
Il controller è accompagnato dalla distribuzione delle seguenti definizioni di risorse personalizzate Kubernetes: `meshes`, `virtual services`, `virtual nodes` e `virtual routers`. Il controller controlla la creazione, la modifica e l'eliminazione delle risorse personalizzate e apporta modifiche alle risorse App Mesh[Reti di servizio](meshes.md),[Servizi virtuali](virtual_services.md),[Nodi virtuali](virtual_nodes.md), [Gateway virtuali](virtual_gateways.md)[Percorsi gateway](gateway-routes.md), [Router virtuali](virtual_routers.md) (incluse[Percorsi](routes.md)) corrispondenti tramite l'API App Mesh. Per saperne di più o contribuire al controller, consulta il [GitHubprogetto](https://github.com/aws/aws-app-mesh-controller-for-k8s).
Il controller installa anche un webhook che inserisce i seguenti container nei pod Kubernetes etichettandoli con il nome che specifichi.
+ **Proxy App Mesh Envoy**: Envoy utilizza la configurazione definita nel piano di controllo App Mesh per determinare dove inviare il traffico dell'applicazione.
+ **App Mesh proxy route manager**: aggiorna `iptables` le regole nello spazio dei nomi di rete di un pod che instradano il traffico in entrata e in uscita tramite Envoy. Questo container viene eseguito come container init Kubernetes all'interno del pod.
## Prerequisiti
+ Una comprensione esistente dei concetti di App Mesh. Per ulteriori informazioni, consulta [Che cos'è AWS App Mesh?](what-is-app-mesh.md).
+ Un’adeguata conoscenza dei concetti di Kubernetes Per ulteriori informazioni, consulta [Cos'è Kubernetes nella documentazione di Kubernetes](https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/).
+ Un cluster Kubernetes esistente. Se non disponi di un cluster esistente, consulta la sezione Guida [introduttiva ad Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) nella *Guida per l'utente di Amazon EKS*. Se stai eseguendo il tuo cluster Kubernetes su Amazon EC2, assicurati che Docker sia autenticato nel repository Amazon ECR in cui si trova l'immagine Envoy. Per ulteriori informazioni, consulta [Envoy image](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html), [Registry authentication](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) in Amazon Elastic Container Registry User Guide e [Pull an Image from a Private Registry](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) nella documentazione di Kubernetes.
+ App Mesh supporta i servizi Linux registrati con DNS o entrambi. AWS Cloud Map Per utilizzare questa guida introduttiva, è consigliabile avere tre servizi esistenti registrati con DNS. Le procedure descritte in questo argomento presuppongono che i servizi esistenti abbiano un nome `serviceA` `serviceBv2` e che tutti i servizi siano individuabili tramite uno spazio dei nomi denominato. `serviceB` `apps.local`
Puoi creare una mesh dei servizi e le relative risorse anche se i servizi non esistono, ma non puoi utilizzare la mesh fino a quando non hai distribuito i servizi effettivi.
+ È installata la AWS CLI versione 1.18.116 o successiva o 2.0.38 o successiva. [Per installare o aggiornare il AWS CLI, vedere Installazione di. AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)
+ Un client `kubectl` configurato per comunicare con il cluster Kubernetes. Se utilizzi Amazon Elastic Kubernetes Service, puoi utilizzare le istruzioni per `[kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)` l'installazione e la configurazione di un file. `[kubeconfig](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html)`
+ Helm versione 3.0 o successiva installato. Se non hai installato Helm, consulta [Using Helm with Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/helm.html) nella Guida per *l'utente di Amazon EKS*.
+ Al momento Amazon EKS supporta `IPv6_ONLY` solo `IPv4_ONLY` e solo le preferenze IP, poiché Amazon EKS attualmente supporta solo pod in grado di servire solo `IPv4` traffico o solo `IPv6` traffico.
Le fasi rimanenti presuppongono che i servizi effettivi siano denominati `serviceA`, `serviceB` e `serviceBv2` e che tutti i servizi siano individuabili tramite uno spazio dei nomi denominato `apps.local`.
## Fase 1: installazione deii componenti di integrazione
Installa i componenti di integrazione una sola volta in ogni cluster che ospita i pod che desideri utilizzare con App Mesh.
**Per installare i componenti di integrazione**
1. Le fasi rimanenti di questa procedura richiedono un cluster senza una versione non definitiva del controller installata. Se hai installato una versione non definitiva o non sei sicuro di averla installata, puoi scaricare ed eseguire uno script che verifica se nel tuo cluster è installata una versione non definitiva.
```
curl -o pre_upgrade_check.sh https://raw.githubusercontent.com/aws/eks-charts/master/stable/appmesh-controller/upgrade/pre_upgrade_check.sh
sh ./pre_upgrade_check.sh
```
Se lo script restituisce `Your cluster is ready for upgrade. Please proceed to the installation instructions`, puoi procedere alla fase successiva. Se viene restituito un messaggio diverso, è necessario completare la procedura di aggiornamento prima di continuare. [Per ulteriori informazioni sull'aggiornamento di una versione non definitiva, consulta Upgrade on.](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#upgrade) GitHub
1. Aggiungi il repository `eks-charts` a Helm.
```
helm repo add eks https://aws.github.io/eks-charts
```
1. Installa le definizioni di risorse personalizzate (CRD) di App Mesh Kubernetes.
```
kubectl apply -k "https://github.com/aws/eks-charts/stable/appmesh-controller/crds?ref=master"
```
1. Crea uno spazio dei nomi Kubernetes per il controller.
```
kubectl create ns appmesh-system
```
1. Imposta le seguenti variabili per utilizzarle nelle prossime fasi. Sostituisci `cluster-name` e `Region-code` con i valori per il cluster esistente.
```
export CLUSTER_NAME=cluster-name
export AWS_REGION=Region-code
```
1. (Facoltativo) Se vuoi eseguire il controller su Fargate devi creare un profilo Fargate. Se non lo hai `eksctl` installato, consulta [Installazione o aggiornamento `eksctl` nella Guida per l'](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl)*utente di Amazon EKS*. Se preferisci creare il profilo utilizzando la console, consulta [Creazione di un profilo Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) nella Guida per *l'utente di Amazon EKS*.
```
eksctl create fargateprofile --cluster $CLUSTER_NAME --name appmesh-system --namespace appmesh-system
```
1. Crea un provider di identità OpenID Connect (OIDC) per il cluster. Se non lo hai `eksctl` installato, puoi installarlo seguendo le istruzioni in [Installazione o aggiornamento nella Guida per l'`eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl)*utente di Amazon EKS*. Se preferisci creare il provider utilizzando la console, consulta la sezione [Abilitazione dei ruoli IAM per gli account di servizio sul tuo cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) nella *Amazon EKS User Guide*.
```
eksctl utils associate-iam-oidc-provider \
--region=$AWS_REGION \
--cluster $CLUSTER_NAME \
--approve
```
1. Crea un ruolo IAM, associa le politiche [https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSCloudMapFullAccess$jsonEditor](https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSCloudMapFullAccess$jsonEditor) AWS gestite ad esso e associalo all'account del servizio `appmesh-controller` Kubernetes. [https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSAppMeshFullAccess$jsonEditor](https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSAppMeshFullAccess$jsonEditor) Il ruolo consente al controller di aggiungere, rimuovere e modificare risorse App Mesh.
**Nota**
Il comando crea un ruolo AWS IAM con un nome generato automaticamente. Non puoi specificare il nome del ruolo IAM creato.
```
eksctl create iamserviceaccount \
--cluster $CLUSTER_NAME \
--namespace appmesh-system \
--name appmesh-controller \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess,arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--override-existing-serviceaccounts \
--approve
```
Se preferisci creare l'account di servizio utilizzando Console di gestione AWS o AWS CLI, consulta [Creazione di un ruolo e di una politica IAM per il tuo account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) nella *Guida per l'utente di Amazon EKS*. Se utilizzi Console di gestione AWS o AWS CLI per creare l'account, devi anche mappare il ruolo a un account di servizio Kubernetes. Per ulteriori informazioni, consulta [Specificare un ruolo IAM per il tuo account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) nella *Amazon EKS User Guide*.
1.
**Implementa il controller App Mesh. Per un elenco di tutte le opzioni di configurazione, vedi [Configuration](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) on GitHub.**
1. Per distribuire il controller App Mesh per un cluster privato, devi prima abilitare App Mesh e gli endpoint Amazon VPC di rilevamento dei servizi nella sottorete privata collegata. È inoltre necessario impostare il. `accountId`
```
--set accountId=$AWS_ACCOUNT_ID
```
Per abilitare il tracciamento a raggi X in un cluster privato, abilita gli endpoint Amazon VPC X-Ray e Amazon ECR. Il controller lo utilizza `public.ecr.aws/xray/aws-xray-daemon:latest` per impostazione predefinita, quindi trasferisci questa immagine in locale e [inseriscila nel tuo repository ECR personale](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html).
**Nota**
[Gli endpoint Amazon VPC](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html) attualmente non supportano gli archivi pubblici Amazon ECR.
L'esempio seguente mostra l'implementazione del controller con configurazioni per X-Ray.
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system \
--set region=$AWS_REGION \
--set serviceAccount.create=false \
--set serviceAccount.name=appmesh-controller \
--set accountId=$AWS_ACCOUNT_ID \
--set log.level=debug \
--set tracing.enabled=true \
--set tracing.provider=x-ray \
--set xray.image.repository=your-account-id.dkr.ecr.your-region.amazonaws.com/your-repository \
--set xray.image.tag=your-xray-daemon-image-tag
```
Verifica se il demone X-Ray viene iniettato correttamente durante l'associazione della distribuzione dell'applicazione con il nodo o il gateway virtuale.
Per ulteriori informazioni, consulta [Private Clusters](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) nella *Amazon EKS User Guide*.
1. Implementa il controller App Mesh per altri cluster. Per un elenco di tutte le opzioni di configurazione, vedi [Configuration](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) on. GitHub
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system \
--set region=$AWS_REGION \
--set serviceAccount.create=false \
--set serviceAccount.name=appmesh-controller
```
**Nota**
Se la tua famiglia di cluster Amazon EKS lo è`IPv6`, imposta il nome del cluster durante la distribuzione del controller App Mesh aggiungendo la seguente opzione al comando `--set clusterName=$CLUSTER_NAME` precedente.
**Importante**
Se il cluster si trova in `me-south-1``ap-east-1`,`ap-southeast-3`, `eu-south-1``il-central-1`, o `af-south-1` Regioni, è necessario aggiungere la seguente opzione al comando precedente:
Sostituisci *account-id* e *Region-code* con uno dei set di valori appropriati.
```
--set image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/amazon/appmesh-controller
```
772975370895.dkr. ecr.me-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
856666278305.dkr. ecr.ap-east-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
422531588944.dkr. ecr.eu-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
564877687649.dkr. ecr.il-central-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
924023996002.dkr. ecr.af-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
[L'immagine precedente è disponibile URIs nel registro delle modifiche.](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub La versione AWS degli account su cui sono presenti le immagini è cambiata`v1.5.0`. Le versioni precedenti delle immagini sono ospitate su AWS account presenti nei registri di immagini dei container Amazon Elastic Kubernetes [Service](https://docs.aws.amazon.com/eks/latest/userguide/add-ons-images.html) di Amazon.
```
--set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
```
772975370895.dkr.ecr.me-south-1.amazonaws. com/amazon/appmesh- controller: v1.13.1
856666278305.dkr.ecr.ap-east-1.amazonaws. com/amazon/appmesh- controller: v1.13.1
909464085924.dkr.ecr.ap-southeast-3.amazonaws. com/amazon/appmesh- controller: v1.13.1
422531588944.dkr.ecr.eu-south-1.amazonaws. com/amazon/appmesh- controllore: v1.13.1
564877687649.dkr.ecr.il-central-1.amazonaws. com/amazon/appmesh- controller: v1.13.1
924023996002.dkr.ecr.af-south-1.amazonaws. com/amazon/appmesh- controller: v1.13.1
```
--set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
```
772975370895.dkr. ecr.me-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
856666278305.dkr. ecr.ap-east-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
422531588944.dkr. ecr.eu-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
564877687649.dkr. ecr.il-central-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
924023996002.dkr. ecr.af-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
**Importante**
Solo la versione v1.9.0.0-prod o successiva è supportata per l'uso con App Mesh.
1. Verifica che la versione del controller sia `v1.4.0` o successiva. [È possibile rivedere il registro delle modifiche.](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub
```
kubectl get deployment appmesh-controller \
-n appmesh-system \
-o json | jq -r ".spec.template.spec.containers[].image" | cut -f2 -d ':'
```
**Nota**
Se si visualizza il log per il container in esecuzione, è possibile che venga visualizzata una riga che include il testo seguente, che può essere tranquillamente ignorato.
```
Neither -kubeconfig nor -master was specified. Using the inClusterConfig. This might not work.
```
## Fase 2: Implementazione delle risorse App Mesh
Quando distribuisci un'applicazione in Kubernetes, crei anche le risorse personalizzate Kubernetes in modo che il controller possa creare le risorse App Mesh corrispondenti. La procedura seguente consente di distribuire le risorse App Mesh con alcune delle relative funzionalità. Puoi trovare esempi di manifest per la distribuzione di altre funzionalità di risorse App Mesh nelle `v1beta2` sottocartelle di molte delle cartelle di funzionalità elencate nelle procedure dettagliate di [App Mesh](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs) su. GitHub
**Importante**
Dopo che il controller ha creato una risorsa App Mesh, ti consigliamo di apportare modifiche o eliminare la risorsa App Mesh solo utilizzando il controller. Se apporti modifiche o elimini la risorsa utilizzando App Mesh, il controller non cambierà o ricreerà la risorsa App Mesh modificata o eliminata per dieci ore, per impostazione predefinita. Puoi configurare un periodo inferiore. Per ulteriori informazioni, consulta [Configurazione](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) su. GitHub
**Per distribuire risorse App Mesh**
1. Crea uno spazio dei nomi Kubernetes in cui distribuire le risorse App Mesh.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `namespace.yaml`.
```
apiVersion: v1
kind: Namespace
metadata:
name: my-apps
labels:
mesh: my-mesh
appmesh.k8s.aws/sidecarInjectorWebhook: enabled
```
1. Crea il namespace.
```
kubectl apply -f namespace.yaml
```
1. Crea una mesh di servizi App Mesh.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `mesh.yaml`. Il file viene utilizzato per creare una risorsa mesh denominata`my-mesh`. Una mesh dei servizi è un limite logico per il traffico di rete tra i servizi che si trovano al suo interno.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: Mesh
metadata:
name: my-mesh
spec:
namespaceSelector:
matchLabels:
mesh: my-mesh
```
1. Crea la mesh.
```
kubectl apply -f mesh.yaml
```
1. Visualizza i dettagli della risorsa mesh Kubernetes creata.
```
kubectl describe mesh my-mesh
```
Output
```
Name: my-mesh
Namespace:
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"Mesh","metadata":{"annotations":{},"name":"my-mesh"},"spec":{"namespaceSelector":{"matchLa...
API Version: appmesh.k8s.aws/v1beta2
Kind: Mesh
Metadata:
Creation Timestamp: 2020-06-17T14:51:37Z
Finalizers:
finalizers.appmesh.k8s.aws/mesh-members
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 1
Resource Version: 6295
Self Link: /apis/appmesh.k8s.aws/v1beta2/meshes/my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-mesh
Namespace Selector:
Match Labels:
Mesh: my-mesh
Status:
Conditions:
Last Transition Time: 2020-06-17T14:51:37Z
Status: True
Type: MeshActive
Mesh ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh
Observed Generation: 1
Events:
```
1. Visualizza i dettagli sulla mesh del servizio App Mesh creata dal controller.
```
aws appmesh describe-mesh --mesh-name my-mesh
```
Output
```
{
"mesh": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh",
"createdAt": "2020-06-17T09:51:37.920000-05:00",
"lastUpdatedAt": "2020-06-17T09:51:37.920000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {},
"status": {
"status": "ACTIVE"
}
}
}
```
1. Crea un nodo virtuale App Mesh. Un nodo virtuale funge da puntatore logico a una distribuzione Kubernetes.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `virtual-node.yaml`. Il file viene utilizzato per creare un nodo virtuale App Mesh denominato `my-service-a` nel *`my-apps`* namespace. Il nodo virtuale rappresenta un servizio Kubernetes creato in una fase successiva. Il valore di `hostname` è il nome host DNS completo del servizio effettivo rappresentato da questo nodo virtuale.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualNode
metadata:
name: my-service-a
namespace: my-apps
spec:
podSelector:
matchLabels:
app: my-app-1
listeners:
- portMapping:
port: 80
protocol: http
serviceDiscovery:
dns:
hostname: my-service-a.my-apps.svc.cluster.local
```
I nodi virtuali hanno funzionalità, come la end-to-end crittografia e i controlli di integrità, che non sono trattate in questo tutorial. Per ulteriori informazioni, consulta [Nodi virtuali](virtual_nodes.md). Per visualizzare tutte le impostazioni disponibili per un nodo virtuale che puoi impostare nelle specifiche precedenti, esegui il comando seguente.
```
aws appmesh create-virtual-node --generate-cli-skeleton yaml-input
```
1. Distribuisci il nodo virtuale.
```
kubectl apply -f virtual-node.yaml
```
1. Visualizza i dettagli della risorsa nodo virtuale Kubernetes creata.
```
kubectl describe virtualnode my-service-a -n my-apps
```
Output
```
Name: my-service-a
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualNode","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"},"s...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualNode
Metadata:
Creation Timestamp: 2020-06-17T14:57:29Z
Finalizers:
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 2
Resource Version: 22545
Self Link: /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualnodes/my-service-a
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-service-a_my-apps
Listeners:
Port Mapping:
Port: 80
Protocol: http
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Pod Selector:
Match Labels:
App: nginx
Service Discovery:
Dns:
Hostname: my-service-a.my-apps.svc.cluster.local
Status:
Conditions:
Last Transition Time: 2020-06-17T14:57:29Z
Status: True
Type: VirtualNodeActive
Observed Generation: 2
Virtual Node ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
Events:
```
1. Visualizza i dettagli del nodo virtuale creato dal controller in App Mesh.
**Nota**
Anche se il nome del nodo virtuale creato in Kubernetes è `my-service-a`, il nome del nodo virtuale creato in App Mesh è `my-service-a_my-apps`. Il controller aggiunge il nome dello spazio dei nomi Kubernetes al nome del nodo virtuale App Mesh quando crea la risorsa App Mesh. Il nome dello spazio dei nomi viene aggiunto perché in Kubernetes è possibile creare nodi virtuali con lo stesso nome in diversi namespace, ma in App Mesh un nome di nodo virtuale deve essere univoco all'interno di una mesh.
```
aws appmesh describe-virtual-node --mesh-name my-mesh --virtual-node-name my-service-a_my-apps
```
Output
```
{
"virtualNode": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps",
"createdAt": "2020-06-17T09:57:29.840000-05:00",
"lastUpdatedAt": "2020-06-17T09:57:29.840000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"backends": [],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "my-service-a.my-apps.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "my-service-a_my-apps"
}
}
```
1. Crea un router virtuale App Mesh. I router virtuali gestiscono il traffico per uno o più servizi virtuali all'interno della mesh.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `virtual-router.yaml`. Il file viene utilizzato per creare un router virtuale per indirizzare il traffico verso il nodo virtuale denominato `my-service-a` creato nel passaggio precedente. Il controller crea il router virtuale App Mesh e le risorse di routing. Puoi specificare molte più funzionalità per i percorsi e utilizzare protocolli diversi da `http`. Per ulteriori informazioni, consultare [Router virtuali](virtual_routers.md) e [Percorsi](routes.md). Nota che il nome del nodo virtuale a cui si fa riferimento è il nome del nodo virtuale Kubernetes, non il nome del nodo virtuale App Mesh creato in App Mesh dal controller.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualRouter
metadata:
namespace: my-apps
name: my-service-a-virtual-router
spec:
listeners:
- portMapping:
port: 80
protocol: http
routes:
- name: my-service-a-route
httpRoute:
match:
prefix: /
action:
weightedTargets:
- virtualNodeRef:
name: my-service-a
weight: 1
```
(Facoltativo) Per visualizzare tutte le impostazioni disponibili per un router virtuale che puoi configurare nelle specifiche precedenti, esegui il comando seguente.
```
aws appmesh create-virtual-router --generate-cli-skeleton yaml-input
```
Per visualizzare tutte le impostazioni disponibili per un percorso che è possibile impostare nelle specifiche precedenti, esegui il comando seguente.
```
aws appmesh create-route --generate-cli-skeleton yaml-input
```
1. Distribuisci il router virtuale.
```
kubectl apply -f virtual-router.yaml
```
1. Visualizza la risorsa router virtuale Kubernetes creata.
```
kubectl describe virtualrouter my-service-a-virtual-router -n my-apps
```
Output abbreviato
```
Name: my-service-a-virtual-router
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualRouter","metadata":{"annotations":{},"name":"my-service-a-virtual-router","namespac...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualRouter
...
Spec:
Aws Name: my-service-a-virtual-router_my-apps
Listeners:
Port Mapping:
Port: 80
Protocol: http
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Routes:
Http Route:
Action:
Weighted Targets:
Virtual Node Ref:
Name: my-service-a
Weight: 1
Match:
Prefix: /
Name: my-service-a-route
Status:
Conditions:
Last Transition Time: 2020-06-17T15:14:01Z
Status: True
Type: VirtualRouterActive
Observed Generation: 1
Route AR Ns:
My - Service - A - Route: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route
Virtual Router ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps
Events:
```
1. Visualizza la risorsa router virtuale creata dal controller in App Mesh. Hai specificato `my-service-a-virtual-router_my-apps` for`name`, perché quando il controller ha creato il router virtuale in App Mesh, ha aggiunto il nome dello spazio dei nomi Kubernetes al nome del router virtuale.
```
aws appmesh describe-virtual-router --virtual-router-name my-service-a-virtual-router_my-apps --mesh-name my-mesh
```
Output
```
{
"virtualRouter": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps",
"createdAt": "2020-06-17T10:14:01.547000-05:00",
"lastUpdatedAt": "2020-06-17T10:14:01.547000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
```
1. Visualizza la risorsa di percorso creata dal controller in App Mesh. La risorsa route non è stata creata in Kubernetes perché fa parte della configurazione del router virtuale in Kubernetes. Le informazioni sul percorso sono state mostrate nei dettagli della risorsa Kubernetes nella sottofase `c`. Il controller non ha aggiunto il nome dello spazio dei nomi Kubernetes al nome della route App Mesh quando ha creato la route in App Mesh perché i nomi delle route sono unici per un router virtuale.
```
aws appmesh describe-route \
--route-name my-service-a-route \
--virtual-router-name my-service-a-virtual-router_my-apps \
--mesh-name my-mesh
```
Output
```
{
"route": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route",
"createdAt": "2020-06-17T10:14:01.577000-05:00",
"lastUpdatedAt": "2020-06-17T10:14:01.577000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"routeName": "my-service-a-route",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "my-service-a_my-apps",
"weight": 1
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
```
1. Crea un servizio virtuale App Mesh. Un servizio virtuale è un'astrazione di un servizio reale fornita direttamente o indirettamente da un nodo virtuale mediante un router virtuale. I servizi dipendenti chiamano il servizio virtuale con il suo nome. Sebbene il nome non sia importante per App Mesh, consigliamo di denominare il servizio virtuale con il nome di dominio completo del servizio effettivo rappresentato dal servizio virtuale. Assegnando un nome al servizio virtuale in questo modo, non hai la necessità di modificare il codice dell'applicazione per fare riferimento a un nome diverso. Le richieste vengono instradate al nodo virtuale o al router virtuale specificato come provider per il servizio virtuale.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `virtual-service.yaml`. Il file viene utilizzato per creare un servizio virtuale che utilizza un provider di router virtuale per indirizzare il traffico verso il nodo virtuale denominato `my-service-a` creato in un passaggio precedente. Il valore per `awsName` in `spec` è il nome di dominio completo (FQDN) del servizio Kubernetes effettivo riassunto in questo servizio virtuale. Il servizio Kubernetes viene creato in [Fase 3: creazione o aggiornamento dei servizi](#create-update-services). Per ulteriori informazioni, consulta [Servizi virtuali](virtual_services.md).
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualService
metadata:
name: my-service-a
namespace: my-apps
spec:
awsName: my-service-a.my-apps.svc.cluster.local
provider:
virtualRouter:
virtualRouterRef:
name: my-service-a-virtual-router
```
Per visualizzare tutte le impostazioni disponibili per un servizio virtuale che puoi impostare nelle specifiche precedenti, esegui il comando seguente.
```
aws appmesh create-virtual-service --generate-cli-skeleton yaml-input
```
1. Creare il servizio virtuale.
```
kubectl apply -f virtual-service.yaml
```
1. Visualizzare i dettagli della risorsa servizio virtuale Kubernetes creata.
```
kubectl describe virtualservice my-service-a -n my-apps
```
Output
```
Name: my-service-a
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualService","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"}...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualService
Metadata:
Creation Timestamp: 2020-06-17T15:48:40Z
Finalizers:
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 1
Resource Version: 13598
Self Link: /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualservices/my-service-a
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-service-a.my-apps.svc.cluster.local
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Provider:
Virtual Router:
Virtual Router Ref:
Name: my-service-a-virtual-router
Status:
Conditions:
Last Transition Time: 2020-06-17T15:48:40Z
Status: True
Type: VirtualServiceActive
Observed Generation: 1
Virtual Service ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local
Events:
```
1. Visualizza i dettagli della risorsa del servizio virtuale creata dal controller in App Mesh. Il controller Kubernetes non ha aggiunto il nome dello spazio dei nomi Kubernetes al nome del servizio virtuale App Mesh quando ha creato il servizio virtuale in App Mesh perché il nome del servizio virtuale è un FQDN univoco.
```
aws appmesh describe-virtual-service --virtual-service-name my-service-a.my-apps.svc.cluster.local --mesh-name my-mesh
```
Output
```
{
"virtualService": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local",
"createdAt": "2020-06-17T10:48:40.182000-05:00",
"lastUpdatedAt": "2020-06-17T10:48:40.182000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "my-service-a.my-apps.svc.cluster.local"
}
}
```
Sebbene non sia trattato in questo tutorial, il controller può anche implementare App Mesh [Gateway virtuali](virtual_gateways.md) e[Percorsi gateway](gateway-routes.md). Per una procedura dettagliata sulla distribuzione di queste risorse con il controller, consulta [Configuring Inbound Gateway](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-ingress-gateway) o un [manifesto di esempio](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template) che include le risorse su. GitHub
## Fase 3: creazione o aggiornamento dei servizi
A tutti i pod che desideri utilizzare con App Mesh devono essere aggiunti i contenitori collaterali App Mesh. L'iniettore aggiunge automaticamente i container sidecar a qualsiasi pod distribuito con l'etichetta che specifichi.
1. Abilitare l'autorizzazione proxy. Ti consigliamo di abilitare ogni distribuzione Kubernetes per lo streaming solo della configurazione per il proprio nodo virtuale App Mesh.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `proxy-auth.json`. Assicurati di sostituirlo *alternate-colored values* con il tuo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appmesh:StreamAggregatedResources",
"Resource": [
"arn:aws:appmesh:us-east-1:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps"
]
}
]
}
```
------
1. Crea la policy.
```
aws iam create-policy --policy-name my-policy --policy-document file://proxy-auth.json
```
1. Crea un ruolo IAM, allega la policy creata nel passaggio precedente, crea un account di servizio Kubernetes e associa la policy all'account di servizio Kubernetes. Il ruolo consente al controller di aggiungere, rimuovere e modificare risorse App Mesh.
```
eksctl create iamserviceaccount \
--cluster $CLUSTER_NAME \
--namespace my-apps \
--name my-service-a \
--attach-policy-arn arn:aws:iam::111122223333:policy/my-policy \
--override-existing-serviceaccounts \
--approve
```
Se preferisci creare l'account di servizio utilizzando Console di gestione AWS o AWS CLI, consulta [Creazione di un ruolo e di una policy IAM per il tuo account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) nella *Guida per l'utente di Amazon EKS*. Se utilizzi Console di gestione AWS o AWS CLI per creare l'account, devi anche mappare il ruolo a un account di servizio Kubernetes. Per ulteriori informazioni, consulta [Specificare un ruolo IAM per il tuo account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) nella *Amazon EKS User Guide*.
1. (Facoltativo) Se vuoi eseguire la distribuzione nei pod Fargate devi creare un profilo Fargate. Se non lo hai `eksctl` installato, puoi installarlo seguendo le istruzioni in [Installazione o aggiornamento nella Guida per l'`eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl)*utente di Amazon EKS*. Se preferisci creare il profilo utilizzando la console, consulta [Creazione di un profilo Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) nella Guida per *l'utente di Amazon EKS*.
```
eksctl create fargateprofile --cluster my-cluster --region Region-code --name my-service-a --namespace my-apps
```
1. Creare un servizio e una distribuzione Kubernetes. Se disponi di una distribuzione esistente che desideri utilizzare con App Mesh, devi implementare un nodo virtuale, come hai fatto nella fase secondaria `3` di. [Fase 2: Implementazione delle risorse App Mesh](#configure-app-mesh) Aggiorna la distribuzione per assicurarti che la relativa etichetta corrisponda all'etichetta che hai impostato sul nodo virtuale, in modo che i contenitori sidecar vengano aggiunti automaticamente ai pod e i pod vengano ridistribuiti.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `example-service.yaml`. Se cambi il nome dello spazio dei nomi e usi i pod Fargate, il nome dello spazio dei nomi deve corrispondere al nome dello spazio dei nomi definito nel profilo Fargate.
```
apiVersion: v1
kind: Service
metadata:
name: my-service-a
namespace: my-apps
labels:
app: my-app-1
spec:
selector:
app: my-app-1
ports:
- protocol: TCP
port: 80
targetPort: 80
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-service-a
namespace: my-apps
labels:
app: my-app-1
spec:
replicas: 3
selector:
matchLabels:
app: my-app-1
template:
metadata:
labels:
app: my-app-1
spec:
serviceAccountName: my-service-a
containers:
- name: nginx
image: nginx:1.19.0
ports:
- containerPort: 80
```
**Importante**
Il valore per il `app` `matchLabels` `selector` nella specifica deve corrispondere al valore che hai specificato quando hai creato il nodo virtuale nella sottofase `3` di [Fase 2: Implementazione delle risorse App Mesh](#configure-app-mesh). In caso contrario i container sidecar non verranno inseriti nel container. Nell'esempio precedente, il valore dell'etichetta è `my-app-1`. Se distribuisci un gateway virtuale, anziché un nodo virtuale, il `Deployment` manifest deve includere solo il contenitore Envoy. Per ulteriori informazioni sull'immagine da utilizzare, consulta. [Immagine dell'inviato](envoy.md) Per un esempio di manifesto, vedi l'[esempio di implementazione su](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template#L585). GitHub
1. Distribuire il servizio.
```
kubectl apply -f example-service.yaml
```
1. Visualizzare il servizio e la distribuzione.
```
kubectl -n my-apps get pods
```
Output
```
NAME READY STATUS RESTARTS AGE
my-service-a-54776556f6-2cxd9 2/2 Running 0 10s
my-service-a-54776556f6-w26kf 2/2 Running 0 18s
my-service-a-54776556f6-zw5kt 2/2 Running 0 26s
```
1. Visualizzare i dettagli di uno dei pod che è stato distribuito.
```
kubectl -n my-apps describe pod my-service-a-54776556f6-2cxd9
```
Output abbreviato
```
Name: my-service-a-54776556f6-2cxd9
Namespace: my-app-1
Priority: 0
Node: ip-192-168-44-157.us-west-2.compute.internal/192.168.44.157
Start Time: Wed, 17 Jun 2020 11:08:59 -0500
Labels: app=nginx
pod-template-hash=54776556f6
Annotations: kubernetes.io/psp: eks.privileged
Status: Running
IP: 192.168.57.134
IPs:
IP: 192.168.57.134
Controlled By: ReplicaSet/my-service-a-54776556f6
Init Containers:
proxyinit:
Container ID: docker://e0c4810d584c21ae0cb6e40f6119d2508f029094d0e01c9411c6cf2a32d77a59
Image: 111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2
Image ID: docker-pullable://111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager
Port:
Host Port:
State: Terminated
Reason: Completed
Exit Code: 0
Started: Fri, 26 Jun 2020 08:36:22 -0500
Finished: Fri, 26 Jun 2020 08:36:22 -0500
Ready: True
Restart Count: 0
Requests:
cpu: 10m
memory: 32Mi
Environment:
APPMESH_START_ENABLED: 1
APPMESH_IGNORE_UID: 1337
APPMESH_ENVOY_INGRESS_PORT: 15000
APPMESH_ENVOY_EGRESS_PORT: 15001
APPMESH_APP_PORTS: 80
APPMESH_EGRESS_IGNORED_IP: 169.254.169.254
APPMESH_EGRESS_IGNORED_PORTS: 22
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Containers:
nginx:
Container ID: docker://be6359dc6ecd3f18a1c87df7b57c2093e1f9db17d5b3a77f22585ce3bcab137a
Image: nginx:1.19.0
Image ID: docker-pullable://nginx
Port: 80/TCP
Host Port: 0/TCP
State: Running
Started: Fri, 26 Jun 2020 08:36:28 -0500
Ready: True
Restart Count: 0
Environment:
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
envoy:
Container ID: docker://905b55cbf33ef3b3debc51cb448401d24e2e7c2dbfc6a9754a2c49dd55a216b6
Image: 840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod
Image ID: docker-pullable://840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy
Port: 9901/TCP
Host Port: 0/TCP
State: Running
Started: Fri, 26 Jun 2020 08:36:36 -0500
Ready: True
Restart Count: 0
Requests:
cpu: 10m
memory: 32Mi
Environment:
APPMESH_RESOURCE_ARN: arn:aws:iam::111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
APPMESH_PREVIEW: 0
ENVOY_LOG_LEVEL: info
AWS_REGION: us-west-2
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Pulling 30s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
Normal Pulled 23s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
Normal Created 21s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container proxyinit
Normal Started 21s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container proxyinit
Normal Pulling 20s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "nginx:1.19.0"
Normal Pulled 16s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "nginx:1.19.0"
Normal Created 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container nginx
Normal Started 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container nginx
Normal Pulling 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
Normal Pulled 8s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
Normal Created 7s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container envoy
Normal Started 7s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container envoy
```
Nell'output precedente, puoi vedere che i container `proxyinit` e `envoy` sono stati aggiunti al pod dal container. Se hai distribuito il servizio di esempio su Fargate, `envoy` il contenitore è stato aggiunto al pod dal controller, ma `proxyinit` il contenitore no.
1. (Facoltativo) Installa componenti aggiuntivi come Prometheus, Grafana, Jaeger e Datadog. AWS X-Ray Per ulteriori informazioni, consulta [i componenti aggiuntivi di App Mesh](https://github.com/aws/eks-charts#app-mesh-add-ons) GitHub e la sezione [Osservabilità](https://docs.aws.amazon.com/app-mesh/latest/userguide/observability.html) della App Mesh User Guide.
**Nota**
Per altri esempi e procedure dettagliate per App Mesh, consulta l'archivio degli esempi di [App Mesh](https://github.com/aws/aws-app-mesh-examples).
## Fase 4: pulizia
Rimuovere tutte le risorse di esempio create in questo tutorial. Il controller rimuove anche le risorse che sono state create nella mesh del servizio `my-mesh` App Mesh.
```
kubectl delete namespace my-apps
```
Se hai creato un profilo Fargate per il servizio di esempio, rimuovilo.
```
eksctl delete fargateprofile --name my-service-a --cluster my-cluster --region Region-code
```
Elimina la mesh.
```
kubectl delete mesh my-mesh
```
(Facoltativo) È possibile rimuovere i componenti di integrazione Kubernetes.
```
helm delete appmesh-controller -n appmesh-system
```
(Facoltativo) Se hai distribuito i componenti di integrazione Kubernetes su Fargate, elimina il profilo Fargate.
```
eksctl delete fargateprofile --name appmesh-system --cluster my-cluster --region Region-code
```