Amazon non CodeCatalyst è più aperta a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [Come migrare da CodeCatalyst](migration.md). 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à. # Implementazione su Amazon EKS con un flusso di lavoro **Suggerimento** Per un tutorial che mostra come utilizzare l'azione del cluster **Deploy to Kubernetes**, consulta. [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md) Questa sezione descrive come distribuire un'applicazione containerizzata in un cluster Kubernetes utilizzando un flusso di lavoro. CodeCatalyst A tale scopo, è necessario aggiungere l'azione **Deploy to Kubernetes cluster al flusso** di lavoro. Questa azione distribuisce la tua applicazione in un cluster Kubernetes che hai configurato in Amazon Elastic Kubernetes Service (EKS) utilizzando uno o più file manifest Kubernetes. Per [deployment.yaml](deploy-tut-eks.md#deploy-tut-eks-source-files-deployment-yml) un [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md) manifesto di esempio, consulta in. [Per ulteriori informazioni su Kubernetes, consulta la documentazione di Kubernetes.](https://kubernetes.io/docs/home/) Per ulteriori informazioni su Amazon EKS, consulta [Cos'è Amazon EKS?](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) nella *Guida per l'utente di Amazon EKS*. **Topics** + [Come funziona l'azione «Deploy to Kubernetes cluster»](#deploy-action-eks-howitworks) + [Immagine di runtime utilizzata dall'azione «Deploy to Amazon EKS»](#deploy-action-eks-runtime) + [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md) + [Aggiungere l'azione «Deploy to Kubernetes cluster»](deploy-action-eks-adding.md) + [Variabili «Distribuisci su cluster Kubernetes»](deploy-action-eks-variables.md) + [Azione «Distribuisci su cluster Kubernetes» YAML](deploy-action-ref-eks.md) ## Come funziona l'azione «Deploy to Kubernetes cluster» Il cluster **Deploy to Kubernetes funziona come** segue: 1. In fase di esecuzione, l'azione installa l'`kubectl`utilità Kubernetes sulla macchina di elaborazione su cui è in esecuzione l' CodeCatalystazione. L'azione si configura in modo da `kubectl` puntare al cluster Amazon EKS fornito al momento della configurazione dell'azione. L'`kubectl`utilità è necessaria per eseguire il `kubectl apply` comando, quindi. 1. L'azione esegue il `kubectl apply -f my-manifest.yaml` comando, che esegue le istruzioni *my-manifest.yaml* per distribuire l'applicazione come set di contenitori e pod nel cluster configurato. *Per ulteriori informazioni su questo comando, consulta l'argomento [kubectl apply](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply) nella documentazione di riferimento di Kubernetes.* ## Immagine di runtime utilizzata dall'azione «Deploy to Amazon EKS» L'azione **Deploy to Amazon EKS** viene eseguita su un'[immagine di novembre 2022](build-images.md#build.previous-image). Per ulteriori informazioni, consulta [Immagini attive](build-images.md#build-curated-images). # Tutorial: distribuzione di un'applicazione su Amazon EKS In questo tutorial, imparerai come distribuire un'applicazione containerizzata in Amazon Elastic Kubernetes Service utilizzando un flusso di lavoro Amazon, CodeCatalyst Amazon EKS e alcuni altri servizi. AWS L'applicazione distribuita è un semplice «Hello, World\$1» sito web costruito su un'immagine Docker del server web Apache. Il tutorial illustra il lavoro di preparazione richiesto, ad esempio la configurazione di una macchina di sviluppo e di un cluster Amazon EKS, quindi descrive come creare un flusso di lavoro per creare l'applicazione e distribuirla nel cluster. Una volta completata la distribuzione iniziale, il tutorial ti spiega come apportare una modifica all'origine dell'applicazione. Questa modifica fa sì che una nuova immagine Docker venga creata e inserita nel tuo archivio di immagini Docker con nuove informazioni di revisione. La nuova revisione dell'immagine Docker viene quindi distribuita in Amazon EKS. **Suggerimento** Invece di seguire questo tutorial, puoi utilizzare un blueprint che esegua una configurazione completa di Amazon EKS per te. Dovrai utilizzare il blueprint **EKS App Deployment**. Per ulteriori informazioni, consulta [Creare un progetto con un blueprint](projects-create.md#projects-create-console-template). **Topics** + [Prerequisiti](#deploy-tut-eks-prereqs) + [Passaggio 1: configura la tua macchina di sviluppo](#deploy-tut-eks-dev-env-create) + [Fase 2: creare un cluster Amazon EKS](#deploy-tut-eks-cluster) + [Fase 3: creare un repository di immagini Amazon ECR](#deploy-tut-eks-ecr) + [Passaggio 4: Aggiungere i file sorgente](#deploy-tut-eks-source-files) + [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) + [Fase 6: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-eks-import-roles) + [Fase 7: Aggiornare il ConfigMap](#deploy-tut-eks-configmap) + [Passaggio 8: creare ed eseguire un flusso di lavoro](#deploy-tut-eks-workflow) + [Passaggio 9: apporta una modifica ai file sorgente](#deploy-tut-eks-change) + [Eliminazione](#deploy-tut-eks-cleanup) ## Prerequisiti Prima di iniziare questo tutorial: + È necessario uno CodeCatalyst **spazio** Amazon con un AWS account connesso. Per ulteriori informazioni, consulta [Creazione di uno spazio](spaces-create.md). + Nel tuo spazio, hai bisogno di un progetto vuoto chiamato: ``` codecatalyst-eks-project ``` Usa l'opzione **Inizia da zero** per creare questo progetto. Per ulteriori informazioni, consulta [Creare un progetto vuoto in Amazon CodeCatalyst](projects-create.md#projects-create-empty). + Nel tuo progetto, hai bisogno di un **repository di CodeCatalyst sorgenti** vuoto chiamato: ``` codecatalyst-eks-source-repository ``` Per ulteriori informazioni, consulta [Archivia e collabora sul codice con i repository di sorgenti in CodeCatalystArchivia e collabora sul codice con i repository di origine](source.md). + Nel tuo progetto, hai bisogno di un ambiente CodeCatalyst CI/CD (non un **ambiente** di sviluppo) chiamato: ``` codecatalyst-eks-environment ``` Configura questo ambiente come segue: + Scegliete qualsiasi tipo, ad esempio **Non di produzione**. + Connect il tuo AWS account. + Per il **ruolo IAM predefinito**, scegli un ruolo qualsiasi. Specificherai un ruolo diverso in seguito. Per ulteriori informazioni, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md). ## Passaggio 1: configura la tua macchina di sviluppo Il primo passo di questo tutorial è configurare una macchina di sviluppo con alcuni strumenti che utilizzerai durante questo tutorial. Questi strumenti sono: + l'`eksctl`utilità: per la creazione di cluster + l'`kubectl`utilità: un prerequisito per `eksctl` + il AWS CLI — anche un prerequisito per `eksctl` Puoi installare questi strumenti sulla tua macchina di sviluppo esistente, se ne hai una, oppure puoi utilizzare un ambiente di CodeCatalyst sviluppo, basato su cloud. Il vantaggio di un ambiente di CodeCatalyst sviluppo è che è facile da avviare e smontare ed è integrato con altri CodeCatalyst servizi, consentendoti di completare questo tutorial in meno passaggi. Questo tutorial presuppone che utilizzerai un ambiente di CodeCatalyst sviluppo. Le seguenti istruzioni descrivono un modo rapido per avviare un ambiente di CodeCatalyst sviluppo e configurarlo con gli strumenti richiesti, ma se desideri istruzioni dettagliate, consulta: + [Creazione di un ambiente di sviluppo](devenvironment-create.md) in questa guida. + [Installazione di kubectl nella Guida](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) per l'utente di **Amazon EKS**. + [Installazione o aggiornamento di eksctl nella **Amazon** EKS](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) User Guide. + [Installazione o aggiornamento della versione più recente di AWS CLI nella Guida per l'utente](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)*.AWS Command Line Interface * **Per avviare un ambiente di sviluppo** 1. Apri la CodeCatalyst console all'[indirizzo https://codecatalyst.aws/](https://codecatalyst.aws/). 1. Vai al tuo progetto,`codecatalyst-eks-project`. 1. Nel riquadro di navigazione, scegli **Codice**, quindi scegli **Archivi di origine.** 1. Scegli il nome del tuo repository di origine,. `codecatalyst-eks-source-repository` 1. In alto scegli **Create Dev Environment**, quindi scegli **AWS Cloud9 (nel browser).** 1. Assicurati che le opzioni **Work in existing branch** e **main** siano selezionate, quindi scegli **Crea**. Il tuo ambiente di sviluppo viene avviato in una nuova scheda del browser e il tuo repository (`codecatalyst-eks-source-repository`) viene clonato al suo interno. **Per installare e configurare kubectl** 1. Nel terminale Dev Environment, inserisci: ``` curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl ``` 1. Inserisci: ``` chmod +x ./kubectl ``` 1. Inserisci: ``` mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin ``` 1. Inserisci: ``` echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc ``` 1. Inserisci: ``` kubectl version --short --client ``` 1. Verifica che venga visualizzata una versione. Ora hai installato`kubectl`. **Per installare e configurare eksctl** **Nota** `eksctl`non è strettamente necessario perché è possibile `kubectl` utilizzarlo al suo posto. Tuttavia, `eksctl` ha il vantaggio di automatizzare gran parte della configurazione del cluster ed è quindi lo strumento consigliato per questo tutorial. 1. Nel terminale Dev Environment, inserisci: ``` curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp ``` 1. Inserisci: ``` sudo cp /tmp/eksctl /usr/bin ``` 1. Inserisci: ``` eksctl version ``` 1. Verifica che venga visualizzata una versione. Ora hai installato`eksctl`. **Per verificare che AWS CLI sia installato** 1. Nel terminale Dev Environment, inserisci: ``` aws --version ``` 1. Verificate che appaia una versione per verificare che AWS CLI sia installata. Completa le procedure rimanenti per configurarlo AWS CLI con le autorizzazioni necessarie per l'accesso AWS. **Per configurare il AWS CLI** È necessario configurarlo AWS CLI con chiavi di accesso e un token di sessione per consentirgli di accedere ai AWS servizi. Le seguenti istruzioni forniscono un modo rapido per configurare le chiavi e il token, ma se desideri istruzioni dettagliate, consulta [Configurazione del AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) nella *Guida per l'AWS Command Line Interface utente*. 1. Crea un utente IAM Identity Center, come segue: 1. Accedi a Console di gestione AWS e apri la AWS IAM Identity Center console all'indirizzo [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/). (Potresti dover scegliere **Abilita** se non hai mai effettuato l'accesso a IAM Identity Center prima.) **Nota** Assicurati di accedere utilizzando Account AWS il dispositivo connesso al tuo CodeCatalyst spazio. Puoi verificare quale account è connesso accedendo al tuo spazio e scegliendo la scheda **Account AWS**. Per ulteriori informazioni, consulta [Creazione di uno spazio](spaces-create.md). 1. Nel riquadro di navigazione, scegli **Users (Utenti)**, quindi scegli **Add user (Aggiungi utente)**. 1. In **Nome utente**, inserisci: ``` codecatalyst-eks-user ``` 1. In **Password**, scegli **Genera una password monouso da condividere con questo utente**. 1. In **Indirizzo e-mail** e **Conferma indirizzo e-mail**, inserisci un indirizzo e-mail che non esista già in IAM Identity Center. 1. In **Nome**, inserisci: ``` codecatalyst-eks-user ``` 1. In **Cognome**, inserisci: ``` codecatalyst-eks-user ``` 1. In **Nome visualizzato**, mantieni: ``` codecatalyst-eks-user codecatalyst-eks-user ``` 1. Scegli **Next (Successivo)**. 1. Nella pagina **Aggiungi utente ai gruppi**, scegli **Avanti**. 1. Nella pagina **Rivedi e aggiungi utente**, esamina le informazioni e scegli **Aggiungi utente**. Viene visualizzata una finestra **di dialogo con password monouso**. 1. Scegli **Copia**, quindi incolla le informazioni di accesso in un file di testo. Le informazioni di accesso sono costituite dall'URL del portale di AWS accesso, un nome utente e una password monouso. 1. Scegli **Chiudi**. 1. Crea un set di autorizzazioni, come segue: 1. Nel riquadro di navigazione, scegli **Set di autorizzazioni**, quindi scegli **Crea set di autorizzazioni**. 1. Scegli Set di **autorizzazioni predefinito**, quindi seleziona **AdministratorAccess**. Questa politica fornisce autorizzazioni complete a tutti. Servizi AWS 1. Scegli **Next (Successivo)**. 1. In **Nome del set di autorizzazioni**, rimuovi `AdministratorAccess` e inserisci: ``` codecatalyst-eks-permission-set ``` 1. Scegli **Next (Successivo)**. 1. Nella pagina **Rivedi e crea**, esamina le informazioni e scegli **Crea**. 1. Assegna il set di autorizzazioni a`codecatalyst-eks-user`, come segue: 1. Nel riquadro di navigazione, scegli **Account AWS**, quindi seleziona la casella di controllo accanto a Account AWS quella a cui hai attualmente effettuato l'accesso. 1. Scegli **Assegna utenti o gruppi**. 1. Scegli la scheda **Users** (Utenti); 1. Seleziona la casella di controllo accanto a. `codecatalyst-eks-user` 1. Scegli **Next (Successivo)**. 1. Seleziona la casella di controllo accanto a`codecatalyst-eks-permission-set`. 1. Scegli **Next (Successivo)**. 1. Controlla le informazioni e scegli **Invia**. Ora le hai assegnate `codecatalyst-eks-user` e `codecatalyst-eks-permission-set` Account AWS le hai assegnate insieme. 1. Le chiavi `codecatalyst-eks-user` di accesso e il token di sessione di Ottain, come segue: 1. Assicurati di avere l'URL del portale di AWS accesso e il nome utente e la password monouso per`codecatalyst-eks-user`. In precedenza avreste dovuto copiare queste informazioni in un editor di testo. **Nota** Se non disponi di queste informazioni, vai alla pagina dei `codecatalyst-eks-user` dettagli in IAM Identity Center, scegli **Reimposta password**, **Genera una password monouso [...]** e **Reimposta nuovamente la password** per visualizzare le informazioni sullo schermo. 1. Uscire da AWS. 1. Incolla l'URL del portale di AWS accesso nella barra degli indirizzi del browser. 1. Accedi con: + **Nome utente**: ``` codecatalyst-eks-user ``` + **Password**: *one-time-password* 1. In **Imposta nuova password**, inserisci una nuova password e scegli **Imposta nuova password**. Sullo schermo viene visualizzata una **Account AWS**casella. 1. Scegli **Account AWS**, quindi scegli il nome Account AWS a cui hai assegnato l'`codecatalyst-eks-user`utente e il set di autorizzazioni. 1. Successivamente`codecatalyst-eks-permission-set`, scegli Riga di **comando o accesso programmatico**. 1. Copia i comandi al centro della pagina. Sono simili ai seguenti: ``` export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" export AWS_SESSION_TOKEN="session-token" ``` ... *session-token* dov'è una lunga stringa casuale. 1. Aggiungi le chiavi di accesso e il token di sessione a AWS CLI, come segue: 1. Tornate al vostro ambiente di CodeCatalyst sviluppo. 1. Al prompt del terminale, incolla i comandi che hai copiato. Premere Invio. Ora lo hai configurato AWS CLI con chiavi di accesso e un token di sessione. Ora puoi AWS CLI utilizzarlo per completare le attività richieste da questo tutorial. **Importante** Se in qualsiasi momento durante questo tutorial visualizzi messaggi simili a: `Unable to locate credentials. You can configure credentials by running "aws configure".` O: `ExpiredToken: The security token included in the request is expired` ... è perché la tua AWS CLI sessione è scaduta. In questo caso, *non* eseguire il `aws configure` comando. Utilizzate invece le istruzioni riportate nel passaggio 4 di questa procedura che inizia con `Obtain codecatalyst-eks-user's access key and session token` per aggiornare la sessione. ## Fase 2: creare un cluster Amazon EKS In questa sezione, crei un cluster in Amazon EKS. Le istruzioni seguenti descrivono un modo rapido per creare il cluster utilizzando`eksctl`, ma se desideri istruzioni dettagliate, consulta: + [Guida introduttiva a eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) nella **Amazon EKS** User Guide or + Guida [introduttiva alla console e AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) nella **Amazon EKS User Guide** (questo argomento fornisce `kubectl` istruzioni per la creazione del cluster) **Nota** [I cluster privati](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) non sono supportati dall' CodeCatalyst integrazione con Amazon EKS. **Prima di iniziare** Assicurati di aver completato le seguenti attività sulla tua macchina di sviluppo: + Installata l'`eksctl`utilità. + Installata l'`kubectl`utilità. + L'ha installata AWS CLI e configurata con chiavi di accesso e un token di sessione. Per informazioni su come completare queste attività, vedere[Passaggio 1: configura la tua macchina di sviluppo](#deploy-tut-eks-dev-env-create). **Come creare un cluster** **Importante** Non utilizzare l'interfaccia utente del servizio Amazon EKS per creare il cluster perché il cluster non verrà configurato correttamente. Usa l'`eksctl`utilità, come descritto nei passaggi seguenti. 1. Vai al tuo ambiente di sviluppo. 1. Crea un cluster e dei nodi: ``` eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2 ``` Dove: + *codecatalyst-eks-cluster*viene sostituito con il nome che vuoi assegnare al cluster. + *us-west-2*viene sostituito dalla tua regione. Dopo 10-20 minuti, viene visualizzato un messaggio simile al seguente: `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready` **Nota** Vedrai più `waiting for CloudFormation stack` messaggi durante la AWS creazione del cluster. Si tratta di un comportamento normale. 1. Verifica che il cluster sia stato creato correttamente: ``` kubectl cluster-info ``` Verrà visualizzato un messaggio simile al seguente, che indica l'avvenuta creazione del cluster: ``` Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy ``` ## Fase 3: creare un repository di immagini Amazon ECR In questa sezione, crei un repository di immagini privato in Amazon Elastic Container Registry (Amazon ECR). Questo repository memorizza l'immagine Docker per il tutorial. Per ulteriori informazioni su Amazon ECR, consulta la *Amazon Elastic Container Registry User Guide*. **Per creare un archivio di immagini in Amazon ECR** 1. Accedi al tuo ambiente di sviluppo. 1. Crea un repository vuoto in Amazon ECR: ``` aws ecr create-repository --repository-name codecatalyst-eks-image-repo ``` Sostituisci *codecatalyst-eks-image-repo* con il nome che desideri assegnare al repository Amazon ECR. Questo tutorial presuppone che tu abbia dato un nome al tuo repository. `codecatalyst-eks-image-repo` 1. Visualizza i dettagli del repository Amazon ECR: ``` aws ecr describe-repositories \ --repository-names codecatalyst-eks-image-repo ``` 1. Nota il `“repositoryUri”:` valore, ad esempio,. `111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo` Ne avrai bisogno in seguito quando aggiungerai il repository al tuo flusso di lavoro. ## Passaggio 4: Aggiungere i file sorgente In questa sezione, aggiungete i file sorgente dell'applicazione al vostro repository di origine ()`codecatalyst-eks-source-repository`. Sono costituiti da: + Un `index.html` file: mostra un messaggio «Hello, World\$1» messaggio nel browser. + Un Dockerfile: descrive l'immagine di base da utilizzare per l'immagine Docker e i comandi Docker da applicarvi. + Un `deployment.yaml` file: il manifesto di Kubernetes che definisce il servizio e la distribuzione Kubernetes. La struttura delle cartelle è la seguente: ``` |— codecatalyst-eks-source-repository |— Kubernetes |— deployment.yaml |— public-html | |— index.html |— Dockerfile ``` **Topics** + [index.html](#deploy-tut-eks-source-files-index) + [Dockerfile](#deploy-tut-eks-source-files-dockerfile) + [deployment.yaml](#deploy-tut-eks-source-files-deployment-yml) ### index.html Il `index.html` file mostra un messaggio «Hello, World\$1» messaggio nel browser. **Per aggiungere il file index.html** 1. Vai al tuo ambiente di sviluppo. 1. In`codecatalyst-eks-source-repository`, crea una cartella chiamata`public-html`. 1. In`/public-html`, crea un file chiamato `index.html` con il seguente contenuto: ``` Hello World

Hello, World!

``` 1. Alla riga di comando del terminale, digitate: ``` cd /projects/codecatalyst-eks-source-repository ``` 1. Aggiungi, esegui il commit e invia: ``` git add . git commit -m "add public-html/index.html" git push ``` `index.html`Viene aggiunto al tuo repository in una `public-html` cartella. ### Dockerfile Il Dockerfile descrive l'immagine Docker di base da utilizzare e i comandi Docker da applicarvi. [Per ulteriori informazioni sul Dockerfile, consulta il Dockerfile Reference.](https://docs.docker.com/engine/reference/builder/) Il Dockerfile specificato qui indica di utilizzare l'immagine di base di Apache 2.4 (). `httpd` Include anche istruzioni per copiare un file sorgente chiamato `index.html` in una cartella sul server Apache che serve le pagine Web. L'`EXPOSE`istruzione nel Dockerfile indica a Docker che il contenitore è in ascolto sulla porta 80. **Per aggiungere il Dockerfile** 1. In`codecatalyst-eks-source-repository`, crea un file chiamato `Dockerfile` con il seguente contenuto: ``` FROM httpd:2.4 COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html EXPOSE 80 ``` Non includere un'estensione di file. **Importante** Il Dockerfile deve risiedere nella cartella principale del repository. Il `Docker build` comando del flusso di lavoro si aspetta che sia presente. 1. Aggiungi, esegui il commit e invia: ``` git add . git commit -m "add Dockerfile" git push ``` Il Dockerfile viene aggiunto al tuo repository. ### deployment.yaml In questa sezione, aggiungi un file al tuo repository. `deployment.yaml` Il `deployment.yaml` file è un manifesto di Kubernetes che definisce due tipi o *tipi* di risorse Kubernetes da eseguire: un «servizio» e una «distribuzione». + Il «servizio» implementa un sistema di bilanciamento del carico in Amazon EC2. Il sistema di bilanciamento del carico fornisce un URL pubblico con accesso a Internet e una porta standard (porta 80) che puoi utilizzare per accedere a «Hello, World\$1» applicazione. + La «distribuzione» utilizza tre pod e ogni pod conterrà un contenitore Docker con il comando «Hello, World\$1» applicazione. I tre pod vengono distribuiti sui nodi creati al momento della creazione del cluster. Il manifesto di questo tutorial è breve; tuttavia, un manifesto può includere qualsiasi tipo di risorsa Kubernetes, come pod, job, ingress e policy di rete. Inoltre, puoi utilizzare più file manifest se la distribuzione è complessa. **Per aggiungere un file deployment.yaml** 1. In`codecatalyst-eks-source-repository`, crea una cartella chiamata. `Kubernetes` 1. In`/Kubernetes`, crea un file chiamato `deployment.yaml` con il seguente contenuto: ``` apiVersion: v1 kind: Service metadata: name: my-service labels: app: my-app spec: type: LoadBalancer selector: app: my-app ports: - protocol: TCP port: 80 targetPort: 80 --- apiVersion: apps/v1 kind: Deployment metadata: name: my-deployment labels: app: my-app spec: replicas: 3 selector: matchLabels: app: my-app template: metadata: labels: app: my-app spec: containers: - name: codecatalyst-eks-container # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow image: $REPOSITORY_URI:$IMAGE_TAG ports: - containerPort: 80 ``` 1. Aggiungi, esegui il commit e invia: ``` git add . git commit -m "add Kubernetes/deployment.yaml" git push ``` Il `deployment.yaml` file viene aggiunto al tuo repository in una cartella chiamata`Kubernetes`. Ora hai aggiunto tutti i tuoi file sorgente. Prenditi un momento per ricontrollare il tuo lavoro e assicurati di aver inserito tutti i file nelle cartelle corrette. La struttura delle cartelle è la seguente: ``` |— codecatalyst-eks-source-repository |— Kubernetes |— deployment.yaml |— public-html | |— index.html |— Dockerfile ``` ## Fase 5: Creare AWS ruoli In questa sezione, creerai i ruoli AWS IAM di cui il tuo CodeCatalyst flusso di lavoro avrà bisogno per funzionare. Questi ruoli sono: + **Ruolo di creazione**: concede all'azione di CodeCatalyst compilazione (nel flusso di lavoro) l'autorizzazione ad accedere al tuo AWS account e scrivere su Amazon ECR e Amazon EC2. + **Ruolo di distribuzione**: concede all'azione del **cluster CodeCatalyst Deploy to Kubernetes** (nel flusso di lavoro) l'autorizzazione ad accedere al tuo account e ad Amazon EKS. AWS [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) **Nota** Per risparmiare tempo, puoi creare un singolo ruolo, chiamato `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo, anziché i due ruoli elencati in precedenza. Per ulteriori informazioni, consulta [Creazione del **CodeCatalystWorkflowDevelopmentRole-*spaceName***ruolo per il tuo account e il tuo spazio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tieni presente che il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo ha autorizzazioni molto ampie che possono rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante. Questo tutorial presuppone che stiate creando i due ruoli elencati in precedenza. Per creare i ruoli di compilazione e distribuzione, completa la seguente serie di procedure. **1. Per creare una politica di fiducia per entrambi i ruoli** 1. Vai al tuo ambiente di sviluppo. 1. Nella `Cloud9-long-string` directory, crea un file chiamato `codecatalyst-eks-trust-policy.json` con il seguente contenuto: **2. Per creare la politica di compilazione per il ruolo di compilazione** + Nella `Cloud9-long-string` directory, create un file chiamato `codecatalyst-eks-build-policy.json` con il seguente contenuto: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "ecr:*", "ec2:*" ], "Resource": "*" } ] } ``` ------ **Nota** La prima volta che il ruolo viene utilizzato per eseguire azioni sul flusso di lavoro, utilizzate il carattere jolly nell'informativa sulla politica delle risorse, quindi definite la politica inserendo il nome della risorsa dopo che è disponibile. ``` "Resource": "*" ``` **3. Per creare la politica di distribuzione per il ruolo di distribuzione** + Nella `Cloud9-long-string` directory, create un file chiamato `codecatalyst-eks-deploy-policy.json` con il seguente contenuto: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "eks:DescribeCluster", "eks:ListClusters" ], "Resource": "*" } ] } ``` ------ **Nota** La prima volta che il ruolo viene utilizzato per eseguire azioni sul flusso di lavoro, utilizzate il carattere jolly nell'informativa sulla politica delle risorse, quindi definite la politica inserendo il nome della risorsa dopo che è disponibile. ``` "Resource": "*" ``` Ora hai aggiunto tre documenti di policy al tuo Dev Environment. La struttura delle cartelle ora è simile a questa: ``` |— Cloud9-long-string |— .c9 |— codecatalyst-eks-source-repository |— Kubernetes |— public-html |— Dockerfile codecatalyst-eks-build-policy.json codecatalyst-eks-deploy-policy.json codecatalyst-eks-trust-policy.json ``` **4. Per aggiungere la politica di compilazione a AWS** 1. Nel terminale Dev Environment, inserisci: ``` cd /projects ``` 1. Inserisci: ``` aws iam create-policy \ --policy-name codecatalyst-eks-build-policy \ --policy-document file://codecatalyst-eks-build-policy.json ``` 1. Premere **Invio**. 1. Nell'output del comando, annota il `"arn":` valore, ad esempio`arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy`. Questo ARN ti servirà più tardi. **5. Per aggiungere la politica di distribuzione a AWS** 1. Inserisci: ``` aws iam create-policy \ --policy-name codecatalyst-eks-deploy-policy \ --policy-document file://codecatalyst-eks-deploy-policy.json ``` 1. Premere **Invio**. 1. Nell'output del comando, annota il `"arn":` valore della policy di distribuzione, `arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy` ad esempio. Questo ARN ti servirà più tardi. **6. Per creare il ruolo di costruzione** 1. Inserisci: ``` aws iam create-role \ --role-name codecatalyst-eks-build-role \ --assume-role-policy-document file://codecatalyst-eks-trust-policy.json ``` 1. Premere **Invio**. 1. Inserisci: ``` aws iam attach-role-policy \ --role-name codecatalyst-eks-build-role \ --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy ``` Dove *arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy* viene sostituito dall'ARN della politica di compilazione che hai notato in precedenza. 1. Premere **Invio**. 1. Alla riga di comando del terminale, inserisci: ``` aws iam get-role \ --role-name codecatalyst-eks-build-role ``` 1. Premere **Invio**. 1. Annotate il `"Arn":` valore del ruolo, `arn:aws:iam::111122223333:role/codecatalyst-eks-build-role` ad esempio. Questo ARN ti servirà più tardi. **7. Per creare il ruolo di distribuzione** 1. Inserisci: ``` aws iam create-role \ --role-name codecatalyst-eks-deploy-role \ --assume-role-policy-document file://codecatalyst-eks-trust-policy.json ``` 1. Premere **Invio**. 1. Inserisci: ``` aws iam attach-role-policy \ --role-name codecatalyst-eks-deploy-role \ --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy ``` Dove *arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy* viene sostituito dall'ARN della politica di distribuzione indicata in precedenza. 1. Premere **Invio**. 1. Inserisci: ``` aws iam get-role \ --role-name codecatalyst-eks-deploy-role ``` 1. Premere **Invio**. 1. Nota il `"Arn":` valore del ruolo, ad esempio`arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role`. Questo ARN ti servirà più tardi. Ora hai creato i ruoli di compilazione e distribuzione e li hai annotati. ARNs ## Fase 6: Aggiungere AWS ruoli a CodeCatalyst In questo passaggio, aggiungi build role (`codecatalyst-eks-build-role`) e deploy role (`codecatalyst-eks-deploy-role`) a Account AWS quello che hai collegato al tuo spazio. In questo modo i ruoli sono disponibili per l'uso nel flusso di lavoro. **Per aggiungere ruoli, build e deploy al tuo Account AWS** 1. Nella CodeCatalyst console, accedi al tuo spazio. 1. In alto, scegli **Impostazioni**. 1. Nel riquadro di navigazione, scegli **AWS Account**. Viene visualizzato un elenco di account. 1. Nella colonna **Amazon CodeCatalyst display name**, copia il nome visualizzato del Account AWS luogo in cui hai creato i ruoli di build e deploy. (Potrebbe essere un numero). Questo valore ti servirà in seguito, durante la creazione del flusso di lavoro. 1. Scegli il nome visualizzato. 1. Scegli **Gestisci ruoli dalla console AWS di gestione**. Viene visualizzata la pagina **Aggiungi ruolo IAM CodeCatalyst allo spazio Amazon**. Potrebbe essere necessario effettuare il login per accedere alla pagina. 1. Seleziona **Aggiungi un ruolo esistente che hai creato in IAM**. Viene visualizzato un elenco a discesa. L'elenco mostra i ruoli di compilazione e distribuzione e tutti gli altri ruoli IAM con una policy di fiducia che include i `codecatalyst-runner.amazonaws.com` principali di servizio. `codecatalyst.amazonaws.com` 1. Dall'elenco a discesa, aggiungi: + `codecatalyst-eks-build-role` + `codecatalyst-eks-deploy-role` **Nota** Se vedi`The security token included in the request is invalid`, potrebbe essere perché non disponi delle autorizzazioni giuste. Per risolvere questo problema, esci e accedi nuovamente con l' AWS account che hai usato quando hai creato il tuo CodeCatalyst spazio. AWS 1. Torna alla CodeCatalyst console e aggiorna la pagina. I ruoli di compilazione e distribuzione dovrebbero ora apparire nei ruoli **IAM**. Questi ruoli sono ora disponibili per l'uso nei flussi CodeCatalyst di lavoro. ## Fase 7: Aggiornare il ConfigMap Devi aggiungere il ruolo di distribuzione che hai creato nel `ConfigMap` file Kubernetes [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) per consentire all'azione del cluster **Deploy to Kubernetes (nel tuo flusso di lavoro) la possibilità di accedere e interagire con il cluster**. È possibile utilizzare o eseguire questa attività. `eksctl` `kubectl` **Per configurare il file Kubernetes ConfigMap usando eksctl** + Nel terminale Dev Environment, inserisci: ``` eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2 ``` Dove: + *codecatalyst-eks-cluster*viene sostituito con il nome del cluster Amazon EKS. + *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*viene sostituito dall'ARN del ruolo di distribuzione in cui è stato creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) + *codecatalyst-eks-deploy-role*(accanto a`--username`) viene sostituito dal nome del ruolo di distribuzione in cui è stato creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) **Nota** Se hai deciso di non creare un ruolo di distribuzione, sostituiscilo *codecatalyst-eks-deploy-role* con il nome del `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo. Per ulteriori informazioni su questo ruolo, consulta [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles). + *us-west-2*viene sostituito con la tua regione. Per i dettagli su questo comando, consulta [Gestire gli utenti e i ruoli IAM](https://eksctl.io/usage/iam-identity-mappings/). Viene visualizzato un messaggio simile al seguente: ``` 2023-06-09 00:58:29 [ℹ] checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap 2023-06-09 00:58:29 [ℹ] adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap ``` **Per configurare il file Kubernetes ConfigMap usando kubectl** 1. Nel terminale Dev Environment, inserisci: ``` kubectl edit configmap -n kube-system aws-auth ``` Il ConfigMap file viene visualizzato sullo schermo. 1. Aggiungi il testo in corsivo rosso: ``` # Please edit the object below. Lines beginning with a '#' will be ignored, # and an empty file will abort the edit. If an error occurs while saving this file will be # reopened with the relevant failures. # apiVersion: v1 data: mapRoles: | - groups: - system:bootstrappers - system:nodes rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5 username: system:node:{{EC2PrivateDNSName}} - groups: - system:masters rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role username: codecatalyst-eks-deploy-role mapUsers: | [] kind: ConfigMap metadata: creationTimestamp: "2023-06-08T19:04:39Z" managedFields: ... ``` Dove: + *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*viene sostituito dall'ARN del ruolo di distribuzione in cui è stato creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) + *codecatalyst-eks-deploy-role*(accanto a`username:`) viene sostituito dal nome del ruolo di distribuzione in cui è stato creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) **Nota** Se hai deciso di non creare un ruolo di distribuzione, sostituiscilo *codecatalyst-eks-deploy-role* con il nome del `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo. Per ulteriori informazioni su questo ruolo, consulta [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles). Per i dettagli, consulta [Abilitazione dell'accesso principale IAM al tuo cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) nella **Guida per l'utente di Amazon EKS**. Ora hai assegnato al ruolo di distribuzione e, per estensione, all'azione **Deploy to Amazon EKS**, `system:masters` le autorizzazioni per il tuo cluster Kubernetes. ## Passaggio 8: creare ed eseguire un flusso di lavoro In questo passaggio, crei un flusso di lavoro che prende i tuoi file sorgente, li crea in un'immagine Docker e quindi distribuisce l'immagine in tree pod nel tuo cluster Amazon EKS. Il flusso di lavoro è costituito dai seguenti elementi costitutivi eseguiti in sequenza: + Un trigger: questo trigger avvia l'esecuzione automatica del flusso di lavoro quando si invia una modifica al repository di origine. Per ulteriori informazioni sui trigger, consulta [L'avvio di un flusso di lavoro viene eseguito automaticamente utilizzando i trigger](workflows-add-trigger.md). + Un'azione di compilazione (`BuildBackend`): all'attivazione, l'azione crea l'immagine Docker utilizzando il Dockerfile e la invia ad Amazon ECR. L'azione di compilazione aggiorna anche `$IMAGE_TAG` le variabili `$REPOSITORY_URI` and nel `deployment.yaml` file con i valori corretti, quindi crea un elemento di output di questo file e di qualsiasi altro file nella cartella. `Kubernetes` In questo tutorial, l'unico file nella `Kubernetes` cartella è, `deployment.yaml` ma è possibile includere altri file. L'artefatto viene utilizzato come input per l'azione di distribuzione, che viene successiva. Per ulteriori informazioni sull'azione di creazione, consulta. [Creazione con flussi di lavoro](build-workflow-actions.md) + A deploy action (`DeployToEKS`): al termine dell'azione di compilazione, l'azione deploy cerca l'artefatto di output generato dall'azione di compilazione (`Manifests`) e trova il `deployment.yaml` file al suo interno. L'azione segue quindi le istruzioni contenute nel `deployment.yaml` file per eseguire tre pod, ciascuno contenente un singolo «Hello, World\$1» Contenitore Docker: all'interno del tuo cluster Amazon EKS. **Come creare un flusso di lavoro** 1. Vai alla console. CodeCatalyst 1. Vai al tuo progetto (`codecatalyst-eks-project`). 1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.** 1. **Scegli Crea flusso di lavoro.** 1. Per **Source repository**, scegli`codecatalyst-eks-source-repository`. 1. Per **Branch**, scegli`main`. 1. Scegli **Create** (Crea). 1. Elimina il codice di esempio YAML. 1. Aggiungi il seguente codice YAML per creare un nuovo file di definizione del flusso di lavoro: **Nota** Per ulteriori informazioni sul file di definizione del flusso di lavoro, vedere. [Definizione YAML del flusso di lavoro](workflow-reference.md) **Nota** Nel codice YAML che segue, puoi omettere le `Connections:` sezioni se lo desideri. Se ometti queste sezioni, devi assicurarti che il ruolo specificato nel campo **Default IAM role** nel tuo ambiente includa le autorizzazioni e le policy di fiducia di entrambi i ruoli descritte in. [Fase 6: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-eks-import-roles) Per ulteriori informazioni sulla configurazione di un ambiente con un ruolo IAM predefinito, consulta. [Creazione di un ambiente](deploy-environments-creating-environment.md) ``` Name: codecatalyst-eks-workflow SchemaVersion: 1.0 Triggers: - Type: PUSH Branches: - main Actions: BuildBackend: Identifier: aws/build@v1 Environment: Name: codecatalyst-eks-environment Connections: - Name: codecatalyst-account-connection Role: codecatalyst-eks-build-role Inputs: Sources: - WorkflowSource Variables: - Name: REPOSITORY_URI Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo - Name: IMAGE_TAG Value: ${WorkflowSource.CommitId} Configuration: Steps: #pre_build: - Run: echo Logging in to Amazon ECR... - Run: aws --version - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com #build: - Run: echo Build started on `date` - Run: echo Building the Docker image... - Run: docker build -t $REPOSITORY_URI:latest . - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG #post_build: - Run: echo Build completed on `date` - Run: echo Pushing the Docker images... - Run: docker push $REPOSITORY_URI:latest - Run: docker push $REPOSITORY_URI:$IMAGE_TAG # Replace the variables in deployment.yaml - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g" - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g" - Run: cat Kubernetes/* # The output artifact will be a zip file that contains Kubernetes manifest files. Outputs: Artifacts: - Name: Manifests Files: - "Kubernetes/*" DeployToEKS: DependsOn: - BuildBackend Identifier: aws/kubernetes-deploy@v1 Environment: Name: codecatalyst-eks-environment Connections: - Name: codecatalyst-account-connection Role: codecatalyst-eks-deploy-role Inputs: Artifacts: - Manifests Configuration: Namespace: default Region: us-west-2 Cluster: codecatalyst-eks-cluster Manifests: Kubernetes/ ``` Nel codice precedente, sostituisci: + Entrambe le istanze hanno *codecatalyst-eks-environment* il nome dell'ambiente in cui avete creato. [Prerequisiti](#deploy-tut-eks-prereqs) + Entrambe le istanze *codecatalyst-account-connection* con il nome visualizzato della connessione all'account. Il nome visualizzato potrebbe essere un numero. Per ulteriori informazioni, consulta [Fase 6: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-eks-import-roles). + *codecatalyst-eks-build-role*con il nome del ruolo di costruzione in cui hai creato[Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles). + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo*(nella `Value:` proprietà) con l'URI del repository Amazon ECR in cui hai creato. [Fase 3: creare un repository di immagini Amazon ECR](#deploy-tut-eks-ecr) + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(nel `Run: aws ecr` comando) con l'URI del repository Amazon ECR senza il suffisso dell'immagine (). `/codecatalyst-eks-image-repo` + *codecatalyst-eks-deploy-role*con il nome del ruolo di distribuzione in cui hai creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) + Entrambe le istanze *us-west-2* con il tuo codice AWS regionale. Per un elenco dei codici regionali, consulta [Endpoint regionali](https://docs.aws.amazon.com/general/latest/gr/rande.html) in. *Riferimenti generali di AWS* **Nota** Se hai deciso di non creare ruoli, build and deploy, sostituisci «*codecatalyst-eks-build-role*e» *codecatalyst-eks-deploy-role* con il nome del `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo. Per ulteriori informazioni su questo ruolo, consulta [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles). 1. (Facoltativo) Scegli **Convalida** per assicurarti che il codice YAML sia valido prima di eseguire il commit. 1. Scegli **Applica**. 1. Nella finestra di dialogo **Conferma flusso di lavoro**, inserisci quanto segue: 1. Per il **messaggio** di conferma, rimuovi il testo e inserisci: ``` Add first workflow ``` 1. Per **Repository**, scegli`codecatalyst-eks-source-repository`. 1. Per il **nome del ramo**, scegli principale. 1. Scegli **Applica**. Ora hai creato un flusso di lavoro. L'esecuzione di un flusso di lavoro viene avviata automaticamente a causa del trigger definito nella parte superiore del flusso di lavoro. In particolare, quando hai eseguito il commit (e inviato) del `workflow.yaml` file nell'archivio di origine, il trigger ha avviato l'esecuzione del flusso di lavoro. **Per visualizzare l'avanzamento del flusso di lavoro, esegui** 1. **Nel pannello di navigazione della CodeCatalyst console, scegli **CI/CD**, quindi scegli Flussi di lavoro.** 1. Scegli il flusso di lavoro che hai appena creato,. `codecatalyst-eks-workflow` 1. Scegli **BuildBackend**di vedere lo stato di avanzamento della costruzione. 1. Scegli **DeployToEKS** per vedere lo stato di avanzamento dell'implementazione. Per ulteriori informazioni sulla visualizzazione dei dettagli dell'esecuzione, consulta[Visualizzazione dello stato e dei dettagli dell'esecuzione del flusso di lavoro](workflows-view-run.md). **Per verificare la distribuzione** 1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. A sinistra, in basso, scegli **Load Balancers**. 1. Seleziona il load balancer che è stato creato come parte della tua implementazione Kubernetes. **Se non sei sicuro di quale bilanciamento del carico scegliere, cerca i seguenti tag nella scheda Tag:** + `kubernetes.io/service-name` + `kubernetes.io/cluster/ekstutorialcluster` 1. Con il bilanciamento del carico corretto selezionato, scegli la **scheda Descrizione**. 1. Copia e incolla il valore del **nome DNS** nella barra degli indirizzi del browser. Il messaggio «Hello, World\$1» nel browser viene visualizzata una pagina Web che indica che l'applicazione è stata distribuita correttamente. ## Passaggio 9: apporta una modifica ai file sorgente In questa sezione, apporti una modifica al `index.html` file nel tuo repository di origine. Questa modifica fa sì che il flusso di lavoro crei una nuova immagine Docker, la tagghi con un ID di commit, la invii ad Amazon ECR e la distribuisca in Amazon ECS. **Per modificare il file index.html** 1. Vai al tuo ambiente di sviluppo. 1. Al prompt del terminale, passa al repository dei sorgenti: ``` cd /projects/codecatalyst-eks-source-repository ``` 1. Recupera le ultime modifiche al flusso di lavoro: ``` git pull ``` 1. Aprire `codecatalyst-eks-source-repository/public-html/index.html`. 1. Nella riga 14, modifica il `Hello, World!` testo in`Tutorial complete!`. 1. Aggiungi, conferma e invia: ``` git add . git commit -m "update index.html title" git push ``` L'esecuzione di un flusso di lavoro viene avviata automaticamente. 1. (Facoltativo) Inserisci: ``` git show HEAD ``` Annota l'ID di commit per la `index.html` modifica. Questo ID di commit verrà taggato nell'immagine Docker che verrà distribuita dall'esecuzione del flusso di lavoro appena avviata. 1. Guarda lo stato di avanzamento della distribuzione: 1. **Nella CodeCatalyst console, nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.** 1. Scegli `codecatalyst-eks-workflow` di visualizzare l'ultima esecuzione. 1. Scegliete **BuildBackend**ed **DeployToEKS** per vedere lo stato di avanzamento del flusso di lavoro. 1. Verifica che l'applicazione sia stata aggiornata, come segue: 1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. A sinistra, in basso, scegli **Load Balancers**. 1. Seleziona il load balancer che è stato creato come parte della tua implementazione Kubernetes. 1. Copia e incolla il valore del **nome DNS** nella barra degli indirizzi del browser. Il «Tutorial completo\$1» Nel browser viene visualizzata una pagina Web che indica che è stata implementata correttamente una nuova revisione dell'applicazione. 1. (Facoltativo) In AWS, passa alla console Amazon ECR e verifica che la nuova immagine Docker sia stata etichettata con l'ID di commit del passaggio 7 di questa procedura. ## Eliminazione È necessario ripulire l'ambiente in modo da non addebitare inutilmente i costi delle risorse di archiviazione e di elaborazione utilizzate in questo tutorial. **Per eliminare** 1. Elimina il tuo cluster: 1. Nel terminale Dev Environment, inserisci: ``` eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster ``` Dove: + *us-west-2*viene sostituito dalla tua regione. + *codecatalyst-eks-cluster*viene sostituito dal nome del cluster creato. Dopo 5-10 minuti, il cluster e le risorse associate vengono eliminati, inclusi, a titolo esemplificativo, CloudFormation stack, gruppi di nodi (in Amazon EC2) e sistemi di bilanciamento del carico. **Importante** Se il `eksctl delete cluster` comando non funziona, potrebbe essere necessario aggiornare le credenziali o le credenziali. AWS `kubectl` Se non sei sicuro di quali credenziali aggiornare, aggiorna prima le credenziali. AWS Per aggiornare le credenziali, consulta. AWS [Come posso correggere gli errori «Impossibile individuare le credenziali» e "ExpiredToken"?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks) Per aggiornare le `kubectl` credenziali, consulta. [Come posso correggere gli errori «Impossibile connettersi al server»?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks) 1. Nella AWS console, esegui la pulizia come segue: 1. In Amazon ECR, elimina`codecatalyst-eks-image-repo`. 1. In IAM Identity Center, elimina: 1. `codecatalyst-eks-user` 1. `codecatalyst-eks-permission-set` 1. In IAM, elimina: + `codecatalyst-eks-build-role` + `codecatalyst-eks-deploy-role` + `codecatalyst-eks-build-policy` + `codecatalyst-eks-deploy-policy` 1. Nella CodeCatalyst console, pulisci come segue: 1. Elimina`codecatalyst-eks-workflow`. 1. Eliminare`codecatalyst-eks-environment`. 1. Eliminare`codecatalyst-eks-source-repository`. 1. Elimina il tuo ambiente di sviluppo. 1. Elimina`codecatalyst-eks-project`. In questo tutorial, hai imparato a distribuire un'applicazione su un servizio Amazon EKS utilizzando un CodeCatalyst flusso di lavoro e un'azione cluster **Deploy to Kubernetes**. # Aggiungere l'azione «Deploy to Kubernetes cluster» Utilizza le seguenti istruzioni per aggiungere l'azione **Deploy to Kubernetes cluster al tuo flusso di lavoro**. **Prima di iniziare** Prima di aggiungere l'azione **Deploy to Kubernetes cluster** al flusso di lavoro, devi aver preparato quanto segue: **Suggerimento** Per configurare rapidamente questi prerequisiti, segui le istruzioni riportate in. [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md) + Un cluster Kubernetes in Amazon EKS. Per informazioni sui cluster, consulta i cluster [Amazon EKS nella Guida per](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) **l'utente di Amazon EKS**. + Almeno un Dockerfile che descrive come assemblare l'applicazione in un'immagine Docker. [Per ulteriori informazioni su Dockerfiles, consulta il riferimento a Dockerfile.](https://docs.docker.com/engine/reference/builder/) + *Almeno un file manifest Kubernetes, chiamato file di configurazione o *configurazione* nella documentazione di Kubernetes.* Per ulteriori informazioni, consulta [Gestione](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/) delle risorse nella documentazione di Kubernetes. + Un ruolo IAM che offre all'azione del cluster **Deploy to Kubernetes la possibilità di accedere e interagire con il cluster** Amazon EKS. Per ulteriori informazioni, consulta l'argomento [Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role) nella [Azione «Distribuisci su cluster Kubernetes» YAML](deploy-action-ref-eks.md). Dopo aver creato questo ruolo, devi aggiungerlo a: + Il tuo file Kubernetes ConfigMap . Per informazioni su come aggiungere un ruolo a un ConfigMap file, consulta la sezione [Abilitazione dell'accesso principale IAM al cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) nella **Amazon EKS User Guide**. + CodeCatalyst. Per informazioni su come aggiungere un ruolo IAM a CodeCatalyst, consulta[Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md). + Uno CodeCatalyst spazio, un progetto e un ambiente. Lo spazio e l'ambiente devono essere entrambi collegati all' AWS account in cui verrà distribuita l'applicazione. Per ulteriori informazioni, consultare [Creazione di uno spazio](spaces-create.md), [Creare un progetto vuoto in Amazon CodeCatalyst](projects-create.md#projects-create-empty) e [Implementazione in e Account AWS VPCs](deploy-environments.md). + Un repository di sorgenti supportato da. CodeCatalyst Il repository memorizza i file sorgente dell'applicazione, i Dockerfile e i manifesti di Kubernetes. Per ulteriori informazioni, consulta [Archivia e collabora sul codice con i repository di sorgenti in CodeCatalystArchivia e collabora sul codice con i repository di origine](source.md). ------ #### [ Visual ] **Per aggiungere l'azione «Distribuisci al cluster Kubernetes» utilizzando l'editor visivo** 1. Apri CodeCatalyst la console [all'](https://codecatalyst.aws/)indirizzo https://codecatalyst.aws/. 1. Scegliere il progetto. 1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.** 1. Scegli il nome del tuo flusso di lavoro. Puoi filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro. 1. Scegli **Modifica**. 1. Scegli **Visual**. 1. In alto a sinistra, scegli **\$1 Azioni** per aprire il catalogo delle azioni. 1. **Dall'elenco a discesa, scegli Amazon. CodeCatalyst** 1. Cerca l'azione **Deploy to Kubernetes cluster** ed esegui una delle seguenti operazioni: + Scegli il segno più (**\$1**) per aggiungere l'azione al diagramma del flusso di lavoro e apri il relativo riquadro di configurazione. Or + Scegli **Deploy to Kubernetes** cluster. Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo: + (Facoltativo) Scegliete **Scarica** per [visualizzare il codice sorgente dell'azione](workflows-view-source.md#workflows-view-source.title). + Scegli **Aggiungi al flusso di lavoro** per aggiungere l'azione al diagramma del flusso di lavoro e aprire il relativo riquadro di configurazione. 1. Nelle schede **Ingressi** e **Configurazione**, completa i campi in base alle tue esigenze. Per una descrizione di ogni campo, consulta. [Azione «Distribuisci su cluster Kubernetes» YAML](deploy-action-ref-eks.md) Questo riferimento fornisce informazioni dettagliate su ogni campo (e il valore della proprietà YAML corrispondente) così come appaiono sia nell'editor YAML che in quello visivo. 1. (Facoltativo) Scegliete **Convalida per convalidare il codice YAML** del flusso di lavoro prima di eseguire il commit. 1. **Scegliete **Commit**, inserite un messaggio di commit e scegliete nuovamente Commit.** ------ #### [ YAML ] **Per aggiungere l'azione «Deploy to Kubernetes cluster» utilizzando l'editor YAML** 1. Apri CodeCatalyst la console [all'](https://codecatalyst.aws/)indirizzo https://codecatalyst.aws/. 1. Scegliere il progetto. 1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.** 1. Scegli il nome del tuo flusso di lavoro. Puoi filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro. 1. Scegli **Modifica**. 1. Scegli **YAML**. 1. In alto a sinistra, scegli **\$1 Azioni per aprire il catalogo delle azioni**. 1. **Dall'elenco a discesa, scegli Amazon. CodeCatalyst** 1. Cerca l'azione **Deploy to Kubernetes cluster** ed esegui una delle seguenti operazioni: + Scegli il segno più (**\$1**) per aggiungere l'azione al diagramma del flusso di lavoro e apri il relativo riquadro di configurazione. Or + Scegli **Deploy to Kubernetes** cluster. Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo: + (Facoltativo) Scegliete **Scarica** per [visualizzare il codice sorgente dell'azione](workflows-view-source.md#workflows-view-source.title). + Scegli **Aggiungi al flusso di lavoro** per aggiungere l'azione al diagramma del flusso di lavoro e aprire il relativo riquadro di configurazione. 1. Modifica le proprietà del codice YAML in base alle tue esigenze. Una spiegazione di ogni proprietà disponibile è fornita in. [Azione «Distribuisci su cluster Kubernetes» YAML](deploy-action-ref-eks.md) 1. (Facoltativo) Scegliete **Convalida per convalidare** il codice YAML del flusso di lavoro prima di eseguire il commit. 1. **Scegliete **Commit**, inserite un messaggio di commit e scegliete nuovamente Commit.** ------ # Variabili «Distribuisci su cluster Kubernetes» L'azione **cluster Deploy to Kubernetes** produce e imposta le seguenti variabili in fase di esecuzione. *Queste sono note come variabili predefinite.* Per informazioni su come fare riferimento a queste variabili in un flusso di lavoro, vedere. [Utilizzo di variabili predefinite](workflows-using-predefined-variables.md) | Chiave | Valore | | --- | --- | | cluster | L'Amazon.com Resource Name (ARN) del cluster Amazon EKS su cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster` | | piattaforma di distribuzione | Il nome della piattaforma di distribuzione. Codificato in. `AWS:EKS` | | metadati | Riservata. Metadati in formato JSON relativi al cluster distribuito durante l'esecuzione del flusso di lavoro. | | namespace | Lo spazio dei nomi Kubernetes in cui è stato distribuito il cluster. Ad esempio: `default` | | risorse | Riservata. Metadati in formato JSON relativi alle risorse distribuite durante l'esecuzione del flusso di lavoro. | | server | Il nome dell'endpoint del server API che puoi utilizzare per comunicare con il cluster utilizzando strumenti di gestione come. `kubectl` Per ulteriori informazioni sull'endpoint del servizio API, consulta [Amazon EKS Cluster Endpoint Access Control](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) nella **Amazon EKS User Guide**. Ad esempio: `https://random-string.gr7.us-west-2.eks.amazonaws.com` | # Azione «Distribuisci su cluster Kubernetes» YAML **Di seguito è riportata la definizione YAML dell'azione del cluster Deploy to Kubernetes.** Per informazioni su come utilizzare questa azione, consulta. [Implementazione su Amazon EKS con un flusso di lavoro](deploy-action-eks.md) Questa definizione di azione esiste come sezione all'interno di un file di definizione del flusso di lavoro più ampio. Per ulteriori informazioni su questo file, consulta [Definizione YAML del flusso di lavoro](workflow-reference.md). **Nota** La maggior parte delle proprietà YAML che seguono hanno elementi dell'interfaccia utente corrispondenti nell'editor visivo. **Per cercare un elemento dell'interfaccia utente, usa Ctrl\$1F.** L'elemento verrà elencato con la proprietà YAML associata. ``` # The workflow definition starts here. # See Proprietà di primo livello for details. Name: MyWorkflow SchemaVersion: 1.0 Actions: # The action definition starts here. DeployToKubernetesCluster\$1nn: Identifier: aws/kubernetes-deploy@v1 DependsOn: - build-action Compute: - Type: EC2 | Lambda - Fleet: fleet-name Timeout: timeout-minutes Environment: Name: environment-name Connections: - Name: account-connection-name Role: DeployToEKS Inputs: # Specify a source or an artifact, but not both. Sources: - source-name-1 Artifacts: - manifest-artifact Configuration: Namespace: namespace Region: us-east-1 Cluster: eks-cluster Manifests: manifest-path ``` ## DeployToKubernetesCluster (Obbligatorio) Specificare il nome dell'azione. Tutti i nomi delle azioni devono essere univoci all'interno del flusso di lavoro. I nomi delle azioni sono limitati a caratteri alfanumerici (a-z, A-Z, 0-9), trattini (-) e caratteri di sottolineatura (\$1). Gli spazi non sono consentiti. Non è possibile utilizzare le virgolette per abilitare caratteri e spazi speciali nei nomi delle azioni. Default: `DeployToKubernetesCluster_nn`. Interfaccia utente corrispondente: scheda di configurazione/nome visualizzato **dell'azione** ## Identifier (*DeployToKubernetesCluster*/**Identifier**) (Obbligatorio) Identifica l'azione. Non modificate questa proprietà a meno che non vogliate cambiare la versione. Per ulteriori informazioni, consulta [Specificare la versione dell'azione da utilizzare](workflows-action-versions.md). Default: `aws/kubernetes-deploy@v1`. **Interfaccia utente corrispondente: Workflow diagram/ DeployToKubernetesCluster \$1nn/ aws/kubernetes-deploy @v1 label** ## DependsOn (*DeployToKubernetesCluster*/**DependsOn**) (Facoltativo) Specificate un'azione, un gruppo di azioni o un gate che deve essere eseguito correttamente affinché questa azione possa essere eseguita. Per ulteriori informazioni sulla funzionalità «dipende da», vedere. [Azioni di sequenziamento](workflows-depends-on.md) **Interfaccia utente corrispondente: scheda Ingressi/Dipende da - opzionale** ## Compute (*DeployToKubernetesCluster*/**Compute**) (Facoltativo) Il motore di calcolo utilizzato per eseguire le azioni del flusso di lavoro. È possibile specificare l'elaborazione a livello di flusso di lavoro o a livello di azione, ma non entrambi. Se specificata a livello di flusso di lavoro, la configurazione di calcolo si applica a tutte le azioni definite nel flusso di lavoro. A livello di flusso di lavoro, puoi anche eseguire più azioni sulla stessa istanza. Per ulteriori informazioni, consulta [Condivisione dell'elaborazione tra le azioni](compute-sharing.md). Interfaccia utente corrispondente: *nessuna* ## Type (*DeployToKubernetesCluster*/Compute/**Type**) (Richiesto [Compute](#deploy.action.eks.computename) se incluso) Il tipo di motore di calcolo. È possibile utilizzare uno dei seguenti valori: + **EC2** (editor visivo) o `EC2` (editor YAML) Ottimizzato per la flessibilità durante le operazioni. + **Lambda** (editor visivo) o `Lambda` (editor YAML) Velocità di avvio delle azioni ottimizzate. Per ulteriori informazioni sui tipi di calcolo, consulta [Tipi di calcolo](workflows-working-compute.md#compute.types). **Interfaccia utente corrispondente: configurazione tab/Advanced : opzionale/tipo di calcolo** ## Fleet (*DeployToKubernetesCluster*/Compute/**Fleet**) (Facoltativo) Specificate la macchina o il parco macchine che eseguiranno il flusso di lavoro o le azioni del flusso di lavoro. Con le flotte on-demand, all'avvio di un'azione, il flusso di lavoro fornisce le risorse necessarie e le macchine vengono distrutte al termine dell'azione. Esempi di flotte on-demand:,. `Linux.x86-64.Large` `Linux.x86-64.XLarge` Per ulteriori informazioni sulle flotte on-demand, vedere. [Proprietà del parco istanze on demand](workflows-working-compute.md#compute.on-demand) Con le flotte assegnate, puoi configurare una serie di macchine dedicate per eseguire le azioni del flusso di lavoro. Queste macchine rimangono inattive, pronte a elaborare immediatamente le azioni. Per ulteriori informazioni sulle flotte rifornite, vedere. [Proprietà del parco istanze con provisioning](workflows-working-compute.md#compute.provisioned-fleets) Se `Fleet` viene omesso, l'impostazione predefinita è. `Linux.x86-64.Large` **Interfaccia utente corrispondente: Configurazione tab/Advanced : parco opzionale/di calcolo** ## Timeout (*DeployToKubernetesCluster*/**Timeout**) (Facoltativo) Specificate il periodo di tempo, in minuti (editor YAML) o in ore e minuti (editor visivo), che l'azione può essere eseguita prima che termini l'azione. CodeCatalyst Il minimo è 5 minuti e il massimo è descritto in. [Quote per i flussi di lavoro in CodeCatalyst](workflows-quotas.md) Il timeout predefinito è lo stesso del timeout massimo. **Interfaccia utente corrispondente: scheda di configurazione/timeout - opzionale** ## Environment (*DeployToKubernetesCluster*/**Environment**) (Obbligatorio) Specificare l' CodeCatalyst ambiente da utilizzare con l'azione. L'azione si connette Account AWS all'Amazon VPC opzionale specificato nell'ambiente scelto. L'azione utilizza il ruolo IAM predefinito specificato nell'ambiente per connettersi a e utilizza il ruolo IAM specificato nella [connessione Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) per connettersi ad Amazon VPC. Account AWS **Nota** Se il ruolo IAM predefinito non dispone delle autorizzazioni richieste dall'azione, puoi configurare l'azione per utilizzare un ruolo diverso. Per ulteriori informazioni, consulta [Modifica del ruolo IAM di un'azione](deploy-environments-switch-role.md). Per ulteriori informazioni sugli ambienti, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md) e[Creazione di un ambiente](deploy-environments-creating-environment.md). **Interfaccia utente corrispondente: scheda di configurazione/ambiente** ## Name (*DeployToKubernetesCluster*/Environment/**Name**) (Richiesto se [Environment](#deploy.action.eks.environment) incluso) Specificate il nome di un ambiente esistente che desiderate associare all'azione. **Interfaccia utente corrispondente: scheda di configurazione/ambiente** ## Connections (*DeployToKubernetesCluster*/Environment/**Connections**) (Facoltativo nelle versioni più recenti dell'azione; richiesto nelle versioni precedenti) Specificare la connessione dell'account da associare all'azione. È possibile specificare al massimo una connessione a un account in`Environment`. Se non si specifica una connessione all'account: + L'azione utilizza la Account AWS connessione e il ruolo IAM predefinito specificati nell'ambiente della CodeCatalyst console. Per informazioni sull'aggiunta di una connessione all'account e del ruolo IAM predefinito all'ambiente, consulta[Creazione di un ambiente](deploy-environments-creating-environment.md). + Il ruolo IAM predefinito deve includere le policy e le autorizzazioni richieste dall'azione. Per determinare quali sono tali politiche e autorizzazioni, consulta la descrizione della proprietà **Role nella documentazione** sulla definizione YAML dell'azione. Per ulteriori informazioni sulle connessioni degli account, vedere. [Consentire l'accesso alle AWS risorse con connessione Account AWS](ipa-connect-account.md) Per informazioni sull'aggiunta di una connessione tramite account a un ambiente, vedere[Creazione di un ambiente](deploy-environments-creating-environment.md). Interfaccia utente corrispondente: una delle seguenti a seconda della versione dell'azione: + (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo** + **(Versioni precedenti) Scheda di configurazione/' '/ connessione all'account Environment/account/role AWS ** ## Name (*DeployToKubernetesCluster*/Environment/Connections/**Name**) (Facoltativo) Specificare il nome della connessione all'account. Interfaccia utente corrispondente: una delle seguenti a seconda della versione dell'azione: + (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo** + **(Versioni precedenti) Scheda di configurazione/' '/ connessione all'account Environment/account/role AWS ** ## Role (*DeployToKubernetesCluster*/Environment/Connections/**Role**) (Richiesto se incluso[Connections](#deploy.action.eks.environment.connections)) Specificate il nome del ruolo IAM a cui l'azione **cluster Deploy to Kubernetes** utilizza per accedere. AWS Assicurati di aver [aggiunto il ruolo al tuo CodeCatalyst spazio](ipa-connect-account-addroles.md) e che il ruolo includa le seguenti politiche. Se non specifichi un ruolo IAM, l'azione utilizza il ruolo IAM predefinito elencato nell'[ambiente](deploy-environments.md) nella CodeCatalyst console. Se utilizzi il ruolo predefinito nell'ambiente, assicurati che abbia le seguenti politiche. + La seguente politica di autorizzazione: **avvertimento** Limita le autorizzazioni a quelle mostrate nella seguente politica. L'utilizzo di un ruolo con autorizzazioni più ampie potrebbe rappresentare un rischio per la sicurezza. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "eks:DescribeCluster", "eks:ListClusters" ], "Resource": "*" } ] } ``` ------ **Nota** La prima volta che il ruolo viene utilizzato, utilizza il seguente carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile. ``` "Resource": "*" ``` + La seguente politica di fiducia personalizzata: Assicurati che questo ruolo sia aggiunto a: + Connessione al tuo account. Per ulteriori informazioni sull'aggiunta di un ruolo IAM alla connessione di un account, consulta[Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md). + Il tuo Kubernetes ConfigMap. Per ulteriori informazioni sull'aggiunta di un ruolo IAM a ConfigMap, consulta [Gestire gli utenti e i ruoli IAM nella documentazione](https://eksctl.io/usage/iam-identity-mappings/). `eksctl` **Suggerimento** Vedi anche [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md) per istruzioni su come aggiungere un ruolo IAM alla connessione di un account e ConfigMap. **Nota** Puoi usare il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo con questa azione, se lo desideri. Per ulteriori informazioni su questo ruolo, consulta [Creazione del **CodeCatalystWorkflowDevelopmentRole-*spaceName***ruolo per il tuo account e il tuo spazio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tieni presente che il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo dispone di autorizzazioni di accesso complete, il che può rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante. Interfaccia utente corrispondente: una delle seguenti a seconda della versione di azione: + (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo** + **(Versioni precedenti) Scheda di configurazione/' '/ Ruolo Environment/account/role** ## Inputs (*DeployToKubernetesCluster*/**Inputs**) (Richiesto se incluso[Connections](#deploy.action.eks.environment.connections)) La `Inputs` sezione definisce i dati `DeployToKubernetesCluster` necessari durante l'esecuzione di un flusso di lavoro. **Nota** È consentito un solo input (fonte o artefatto) per azione **Deploy to Amazon EKS**. **Interfaccia utente corrispondente: scheda Input** ## Sources (*DeployToKubernetesCluster*/Inputs/**Sources**) (Richiesto se il file manifest è archiviato in un repository di origine) Se il file o i file manifest di Kubernetes sono archiviati in un repository di origine, specifica l'etichetta di tale repository di origine. Attualmente, l'unica etichetta supportata è. `WorkflowSource` Se i file manifest non sono contenuti in un repository di origine, devono risiedere in un artefatto generato da un'altra azione. Per ulteriori informazioni sulle origini, consulta [Connessione degli archivi di origine ai flussi di lavoro](workflows-sources.md). **Interfaccia utente corrispondente: scheda Input/Sources - opzionale** ## Artifacts - input (*DeployToKubernetesCluster*/Inputs/**Artifacts**) (Richiesto se il file manifest è memorizzato in un elemento [di output di un'azione precedente](workflows-working-artifacts-output.md)) Se il file o i file manifest di Kubernetes sono contenuti in un artefatto generato da un'azione precedente, specifica quell'artefatto qui. Se i tuoi file manifest non sono contenuti in un artefatto, devono risiedere nel tuo repository di origine. Per ulteriori informazioni sugli artefatti, inclusi esempi, vedere. [Condivisione di artefatti e file tra azioni](workflows-working-artifacts.md) **Interfaccia utente corrispondente: scheda di configurazione/artefatti - opzionale** ## Configuration (*DeployToKubernetesCluster*/**Configuration**) (Obbligatorio) Una sezione in cui è possibile definire le proprietà di configurazione dell'azione. Interfaccia utente corrispondente: scheda **Configurazione** ## Namespace (*DeployToKubernetesCluster*/Configuration/**Namespace**) (Facoltativo) Specificate lo spazio dei nomi Kubernetes in cui verrà distribuita l'applicazione Kubernetes. Utilizzalo `default` se non utilizzi namespace con il tuo cluster. Per ulteriori informazioni sugli spazi dei nomi, consulta [Suddivisione del cluster utilizzando gli spazi dei nomi Kubernetes nella documentazione di Kubernetes](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces). Se ometti lo spazio dei `default` nomi, viene utilizzato il valore di. **Interfaccia utente corrispondente: scheda di configurazione/ Namespace** ## Region (*DeployToKubernetesCluster*/Configuration/**Region**) (Obbligatorio) Specificare la AWS regione in cui risiedono il cluster e il servizio Amazon EKS. Per un elenco dei codici regionali, consulta [Endpoint regionali](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes) nel. *Riferimenti generali di AWS* **Interfaccia utente corrispondente: scheda/regione di configurazione** ## Cluster (*DeployToKubernetesCluster*/Configuration/**Cluster**) (Obbligatorio) Specificare il nome di un cluster Amazon EKS esistente. L'azione **Deploy to Kubernetes cluster** distribuirà l'applicazione containerizzata in questo cluster. Per ulteriori informazioni sui cluster Amazon EKS, consulta [Clusters](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) nella **Amazon EKS User Guide**. **Interfaccia utente corrispondente: scheda di configurazione/ Cluster** ## Manifests (*DeployToKubernetesCluster*/Configuration/**Manifests**) (Obbligatorio) *Specificate il percorso dei file manifest di Kubernetes in formato YAML, denominati file di configurazione, file di *configurazione o semplicemente configurazioni nella documentazione* di *Kubernetes*.* Se utilizzi più file manifest, inseriscili in un'unica cartella e fai riferimento a quella cartella. I file manifest vengono elaborati in ordine alfanumerico da Kubernetes, quindi assicurati di anteporre ai nomi dei file numeri o lettere crescenti per controllare l'ordine di elaborazione. Esempio: `00-namespace.yaml` `01-deployment.yaml` Se i file manifest risiedono nel repository di origine, il percorso è relativo alla cartella principale del repository di origine. Se i file si trovano in un elemento di un'azione precedente del workflow, il percorso è relativo alla cartella principale dell'artefatto. Esempi: `Manifests/` `deployment.yaml` `my-deployment.yml` Non utilizzate caratteri jolly (). `*` **Nota** I [grafici Helm](https://helm.sh/docs/topics/charts/) e i file [di personalizzazione](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/) non sono supportati. Per ulteriori informazioni sui file manifest, consulta [Organizzazione delle configurazioni delle risorse](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations) nella documentazione di Kubernetes. **Interfaccia utente corrispondente: scheda di configurazione/ Manifesti**