AWS Cloud9 non è più disponibile per i nuovi clienti. I clienti esistenti di AWS Cloud9 possono continuare a utilizzare il servizio come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
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à.
# Tutorial per AWS Cloud9
Sei nuovo a farlo? AWS Cloud9 Fai un tour dell'IDE in [Nozioni di base: tutorial di base](tutorials-basic.md).
Sperimenta con questi tutorial e il codice di esempio per aumentare le tue conoscenze e la tua sicurezza nell'uso AWS Cloud9 di vari linguaggi e AWS servizi di programmazione.
**Topics**
+ [AWS CLI e tutorial aws-shell](sample-aws-cli.md)
+ [AWS CodeCommit tutorial](sample-codecommit.md)
+ [Tutorial su Amazon DynamoDB](sample-dynamodb.md)
+ [AWS CDK tutorial](sample-cdk.md)
+ [Tutorial LAMP](sample-lamp.md)
+ [WordPress tutorial](sample-wordpress.md)
+ [Tutorial su Java](sample-java.md)
+ [Tutorial in C\$1\$1](sample-cplusplus.md)
+ [Tutorial di Python](sample-python.md)
+ [Tutorial.NET](sample-dotnetcore.md)
+ [Tutorial Node.js](sample-nodejs.md)
+ [Tutorial PHP](sample-php.md)
+ [Ruby](tutorial-ruby.md)
+ [Vai al tutorial](sample-go.md)
+ [TypeScript tutorial](sample-typescript.md)
+ [Tutorial Docker](sample-docker.md)
+ [Tutorial correlati](#samples-additonal)
# AWS CLI e tutorial aws-shell per AWS Cloud9
Il seguente tutorial consente di configurare AWS Command Line Interface (AWS CLI), aws-shell o entrambi in un ambiente di sviluppo. AWS Cloud9 The AWS CLI e aws-shell sono strumenti unificati che forniscono un'interfaccia coerente per interagire con tutte le parti di. AWSÈ possibile utilizzare il AWS CLI invece di the Console di gestione AWS per eseguire rapidamente i comandi con AWS cui interagire e alcuni di questi comandi possono essere eseguiti con o in alternativa utilizzando. AWS CLI AWS CloudShell
Per ulteriori informazioni su AWS CLI, consulta la [Guida AWS Command Line Interface per l'utente](https://docs.aws.amazon.com/cli/latest/userguide/). Per i dettagli su aws-shell, vedi le risorse seguenti:
+ [aws-shell sul sito](https://github.com/awslabs/aws-shell) web GitHub
+ [aws-shell](https://pypi.python.org/pypi/aws-shell) nel sito Web pip
Per un elenco dei comandi che puoi eseguire con cui interagire AWS, consulta AWS CLI il [AWS CLI Command](https://docs.aws.amazon.com/cli/latest/reference/) Reference. È possibile utilizzare gli stessi comandi con AWS CloudShell, ad eccezione del fatto che i comandi vengono avviati senza il `aws` prefisso.
La creazione di questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-aws-cli-prereqs)
+ [Passaggio 1: installa AWS CLI aws-shell o entrambi nel tuo ambiente](#sample-aws-cli-install)
+ [Fase 2: configurare la gestione delle credenziali nell'ambiente](#sample-aws-cli-creds)
+ [Passaggio 3: esegui i comandi di base con AWS CLI o con aws-shell nel tuo ambiente](#sample-aws-cli-run)
+ [Fase 4: pulizia](#sample-aws-cli-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Passaggio 1: installa AWS CLI aws-shell o entrambi nel tuo ambiente
In questo passaggio, usi l' AWS Cloud9 IDE per installare aws-shell o entrambi nel tuo ambiente in modo da poter eseguire comandi con cui interagire. AWS CLI AWS
Se utilizzi un ambiente di sviluppo AWS Cloud9 EC2 e desideri utilizzare solo il AWS CLI, puoi passare direttamente a. [Passaggio 3: esegui i comandi di base con AWS CLI o con aws-shell nel tuo ambiente](#sample-aws-cli-run) Questo perché AWS CLI è già installato in un ambiente EC2 e nell'ambiente è già configurato un set di credenziali di AWS accesso. Per ulteriori informazioni, consulta [AWS credenziali temporanee gestite](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Se non utilizzi un ambiente EC2 installa AWS CLI tramite la procedura descritta di seguito:
1. Con l'ambiente aperto, nell'IDE, controlla se AWS CLI è già installato. Nel terminale, esegui il comando ** `aws --version` **. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale). Se AWS CLI è installato, viene visualizzato il numero di versione, con informazioni come i numeri di versione di Python e il numero di versione del sistema operativo dell'istanza Amazon EC2 o del proprio server. Se AWS CLI è installato, vai avanti a. [Fase 2: configurare la gestione delle credenziali nell'ambiente](#sample-aws-cli-creds)
1. Per installare il AWS CLI, consulta [Installazione di AWS Command Line Interface nella](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *Guida per l'AWS Command Line Interface utente*. Per esempio, in un ambiente EC2 in cui viene eseguito Amazon Linux, esegui questi tre comandi, uno alla volta, nel terminale per installare la AWS CLI.
```
sudo yum -y update # Install the latest system updates.
sudo yum -y install aws-cli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
Ad esempio, in un ambiente EC2 in cui viene eseguito Ubuntu Server, esegui ognuno dei tre comandi seguenti nel terminale per installare la AWS CLI.
```
sudo apt update # Install the latest system updates.
sudo apt install -y awscli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
Per installare aws-shell, procedere come segue:
1. Con l'ambiente aperto, verifica nell'IDE se aws-shell è già installato. Nel terminale, esegui il comando ** `aws-shell` **. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale). Se aws-shell è installato, verrà visualizzato il prompt `aws>`. Se aws-shell è installato, passare direttamente alla [Fase 2: configurare la gestione delle credenziali nell'ambiente](#sample-aws-cli-creds).
1. Per installare aws-shell, puoi usare pip. In questo caso, è necessario che Python sia installato.
Per controllare se Python è già installato (ed eventualmente installarlo, se necessario), seguire le istruzioni nella sezione [Fase 1: installare Python](sample-python.md#sample-python-install) della pagina *Esempio di Python*, quindi torna a questo argomento.
Per controllare se pip è già installato, nel terminale, eseguire il comando ** `pip --version` **. Se pip è installato, verrà visualizzato il numero della versione. Se pip non è installato, installarlo eseguendo ognuno dei tre comandi seguenti nel terminale.
```
wget https://bootstrap.pypa.io/get-pip.py # Get the pip install file.
sudo python get-pip.py # Install pip. (You might need to run 'sudo python2 get-pip.py' or 'sudo python3 get-pip.py' instead, depending on how Python is installed.)
rm get-pip.py # Delete the pip install file, as it is no longer needed.
```
1. Per usare pip per installare aws-shell, esegui il comando seguente.
```
sudo pip install aws-shell
```
## Fase 2: configurare la gestione delle credenziali nell'ambiente
Ogni volta che usi la AWS CLI o la aws-shell per chiamare un AWS servizio, devi fornire un set di credenziali con la chiamata. Queste credenziali determinano se aws-shell dispone delle autorizzazioni appropriate per effettuare quella chiamata. AWS CLI Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.
Se utilizzi un ambiente di sviluppo AWS Cloud9 EC2, puoi passare direttamente a. [Passaggio 3: esegui i comandi di base con AWS CLI o con aws-shell nel tuo ambiente](#sample-aws-cli-run) Questo perché in un ambiente EC2 le credenziali sono già impostate. Per ulteriori informazioni, consulta [AWS credenziali temporanee gestite](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Se non utilizzi un ambiente EC2, dovrai inserire manualmente le credenziali nell'ambiente. A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento.
## Passaggio 3: esegui i comandi di base con AWS CLI o con aws-shell nel tuo ambiente
In questo passaggio, usi AWS CLI o la aws-shell nel tuo ambiente per creare un bucket in Amazon S3, elencare i bucket disponibili e quindi eliminare il bucket.
1. Se desideri utilizzare aws-shell, ma non hai ancora iniziato, avvia aws-shell eseguendo il comando `aws-shell`. Verrà visualizzato il prompt `aws>`.
1. Creare un bucket. Esegui il **`aws s3 mb`**comando con il **`s3 mb`**comando AWS CLI or con aws-shell, fornendo il nome del bucket da creare. In questo esempio, utilizziamo un bucket denominato`cloud9-123456789012-bucket`, dov'è `123456789012` l'ID del tuo account. AWS Per usare un nome diverso, sostituiscilo in tutta la procedura.
```
aws s3 mb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 mb s3://cloud9-123456789012-bucket # For the aws-shell.
```
**Nota**
I nomi dei bucket devono essere unici per tutti gli account AWS, non solo per il tuo AWS account. Il nome del bucket suggerito in precedenza può essere utile per scegliere un nome univoco per il bucket. Se viene visualizzato un messaggio contenente l'errore `BucketAlreadyExists`, sarà necessario eseguire nuovamente il comando, cambiando il nome del bucket.
1. Crea un elenco dei bucket disponibili. Esegui il **`aws s3 ls`**comando con AWS CLI o il **`s3 ls`**comando con aws-shell. Viene visualizzato l'elenco dei bucket disponibili.
1. Elimina il bucket. Esegui il **`aws s3 rb`**comando con AWS CLI o il **`s3 rb`**comando con aws-shell, fornendo il nome del bucket da eliminare.
```
aws s3 rb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 rb s3://cloud9-123456789012-bucket # For the aws-shell.
```
Per confermare se il bucket è stato eliminato, esegui nuovamente il **`aws s3 ls`**comando con AWS CLI o il comando di nuovo con **`s3 ls`**aws-shell. Il nome del bucket eliminato non dovrebbe più comparire nell'elenco.
**Nota**
Se desideri continuare a utilizzare il bucket, non eliminarlo. Per ulteriori informazioni, consulta [Aggiunta di un oggetto a un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) nella *Guida per l'utente di Amazon Simple Storage Service*. Consulta anche la sezione relativa ai [comandi s3](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html.html) nella *documentazione di riferimento ai comandi AWS CLI *. (Ricorda che se non elimini il bucket, potrebbero verificarsi addebiti continui sul tuo account.) AWS
Per continuare a sperimentare AWS CLI, consulta [Working with Amazon Web Services](https://docs.aws.amazon.com/cli/latest/userguide/chap-working-with-services.html) nella *AWS Command Line Interface User Guide* e nel [AWS CLI Command Reference](https://docs.aws.amazon.com/cli/latest/reference/). Per continuare a provare aws-shell, consulta la [documentazione di riferimento ai comandi AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/), tenendo presente che i comandi vengono avviati senza il prefisso `aws`.
## Fase 4: pulizia
Se si sta utilizzando aws-shell, è possibile interromperne l'utilizzo eseguendo il comando ** `.exit` ** oppure ** `.quit` **.
Per evitare addebiti continui AWS sul tuo account dopo aver finito di utilizzare questo esempio, devi eliminare l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# AWS CodeCommit tutorial per AWS Cloud9
È possibile utilizzare il AWS CodeCommit tutorial per configurare un ambiente di AWS Cloud9 sviluppo in cui interagire con un repository di codice remoto. CodeCommit CodeCommit è un servizio di controllo del codice sorgente che è possibile utilizzare per archiviare e gestire in modo privato gli Git archivi in. Cloud AWS Per ulteriori informazioni su CodeCommit, consulta la Guida per l'[AWS CodeCommit utente](https://docs.aws.amazon.com/codecommit/latest/userguide/).
Seguire questo tutorial e creare questo esempio potrebbe comportare dei costi a carico del tuo Account AWS. Questi includono eventuali addebiti per servizi come Amazon EC2 e. CodeCommit Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di AWS CodeCommit](https://aws.amazon.com/codecommit/pricing/).
+ [Prerequisiti](#sample-codecommit-prereqs)
+ [Fase 1: configurare il gruppo IAM con le autorizzazioni di accesso richieste](#sample-codecommit-permissions)
+ [Fase 2: Creare un repository in AWS CodeCommit](#sample-codecommit-create-repo)
+ [Fase 3: connettere l'ambiente al repository remoto](#sample-codecommit-connect-repo)
+ [Fase 4: clonare il repository remoto nell'ambiente](#sample-codecommit-clone-repo)
+ [Fase 5: aggiungere file al repository](#sample-codecommit-add-files)
+ [Fase 6: pulire](#sample-codecommit-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: configurare il gruppo IAM con le autorizzazioni di accesso richieste
Supponiamo che AWS le tue credenziali siano associate a un utente amministratore del tuo Account AWS sito e che tu voglia utilizzare quell'utente per lavorare con Then, CodeCommit vai avanti al [Passaggio 2: Crea un](#sample-codecommit-create-repo) repository in. AWS CodeCommit
È possibile completare questa fase utilizzando la [Console di gestione AWS](#sample-codecommit-permissions-console) o l'[AWS Command Line Interface (AWS CLI)](#sample-codecommit-permissions-cli).
### Impostazione del gruppo IAM con le autorizzazioni di accesso richieste tramite la console
1. Accedi a Console di gestione AWS, se non hai già effettuato l'accesso.
Per questa fase ti consigliamo di effettuare l'accesso utilizzando le credenziali di un utente amministratore nell' Account AWS. Se non è possibile eseguire questa operazione, contatta l'amministratore dell' Account AWS .
1. Apri la console IAM. Per eseguire questa operazione, scegliere **Services (Servizi)** nella barra di navigazione della console. Quindi scegli **IAM**.
1. Scegliere **Groups (Gruppi)**.
1. Scegli il nome del gruppo.
1. Nella scheda **Permissions (Autorizzazioni)**, per **Managed Policies (Policy gestite)**, scegliere **Attach Policy (Collega policy)**.
1. Nell'elenco dei nomi delle policy, seleziona una delle seguenti caselle:
+ Seleziona **AWSCodeCommitPowerUser**per accedere a tutte le funzionalità CodeCommit e alle risorse relative al repository. Tuttavia, ciò non consente di eliminare CodeCommit repository o creare o eliminare risorse relative ai repository in altri, Servizi AWS come Amazon Events. CloudWatch
+ Seleziona **AWSCodeCommitFullAccess**per avere il pieno controllo sui CodeCommit repository e sulle risorse correlate in. Account AWS compresa la possibilità eliminare i repository.
Se nell'elenco non sono presenti questi nomi di policy, immetti il nome della policy nella casella **Filter** (Filtro) per visualizzarla.
1. Scegli **Attach Policy (Collega policy)**.
*Per visualizzare l'elenco delle autorizzazioni di accesso concesse da queste politiche AWS gestite a un gruppo, consulta la sezione Politiche [AWS gestite (predefinite) AWS CodeCommit nella Guida per](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) l'AWS CodeCommit utente.*
Vai avanti alla [Fase 2: Crea un](#sample-codecommit-create-repo) repository in. AWS CodeCommit
### Configura il tuo gruppo IAM con le autorizzazioni di accesso richieste utilizzando il AWS CLI
Esegui il `attach-group-policy` comando IAM, specificando il nome del gruppo e l'Amazon Resource Name (ARN) della policy gestita che descrive AWS le autorizzazioni di accesso richieste. La sintassi è esposta di seguito.
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
Nel comando precedente, sostituisci `MyGroup` con il nome del gruppo. Sostituisci `POLICY_ARN` con l'ARN della policy AWS gestita:
+ `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser`per accedere a tutte le funzionalità CodeCommit e alle risorse relative al repository. Tuttavia, non consente di eliminare CodeCommit repository o creare o eliminare risorse relative ai repository in altri, Servizi AWS come Amazon Events. CloudWatch
+ `arn:aws:iam::aws:policy/AWSCodeCommitFullAccess`per il pieno controllo degli CodeCommit archivi e delle risorse correlate in. Account AWS compresa la possibilità eliminare i repository.
*Per visualizzare l'elenco delle autorizzazioni di accesso concesse da queste politiche AWS gestite a un gruppo, consulta la sezione Politiche [AWS gestite (predefinite) AWS CodeCommit nella Guida per](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) l'AWS CodeCommit utente.*
## Fase 2: Creare un repository in CodeCommit
In questo passaggio, crei un repository di codice remoto CodeCommit utilizzando la CodeCommit console.
Se disponi già di un CodeCommit repository, vai avanti allo [Step 3: Connect Your Environment to the Remote](#sample-codecommit-connect-repo) Repository.
È possibile completare questa fase utilizzando la [Console di gestione AWS](#sample-codecommit-create-repo-console) o l'[AWS Command Line Interface (AWS CLI)](#sample-codecommit-create-repo-cli).
### Crea un repository utilizzando la console CodeCommit
1. Supponiamo di aver effettuato l'accesso Console di gestione AWS come utente amministratore nel passaggio precedente e di non voler utilizzare l'utente amministratore per creare il repository. Quindi, esci da. Console di gestione AWS
1. Apri la CodeCommit console, in [https://console.aws.amazon.com/codecommitt.](https://console.aws.amazon.com/codecommit)
1. Nella barra di navigazione della console, utilizza il selettore delle regioni per selezionare la Regione AWS in cui desideri creare il repository, ad esempio **US East (Ohio)** (Stati Uniti orientali (Ohio).
1. Se viene visualizzata la pagina di benvenuto, seleziona **Get started** (Avvia). Altrimenti seleziona **Create repository (Crea repository)**.
1. Nella pagina **Create repository** (Crea repository), in **Repository name** (Nome repository), immetti un nome per il nuovo repository, ad esempio `MyDemoCloud9Repo`. Se si sceglie un nome diverso, sostituirlo in tutto l'esempio.
1. (Facoltativo) In **Description** (Descrizione), digita una descrizione per il repository, ad esempio puoi immettere `This is a demonstration repository for the AWS Cloud9 sample.`
1. Scegli **Create repository (Crea repository)**. Viene visualizzato il riquadro **Connect to your repository (Connetti al repository)**. Seleziona **Close (Chiudi)**; verrà illustrato come eseguire la connessione al repository in modo diverso più avanti in questo argomento.
Passa alla [Fase 3: connettere l'ambiente al repository remoto](#sample-codecommit-connect-repo).
### Crea un repository utilizzando il CodeCommit AWS CLI
Esegui il comando AWS CodeCommit `create-repository`. Specificare il nome del repository, una descrizione opzionale e il campo in cui Regione AWS creare il repository.
```
aws codecommit create-repository --repository-name MyDemoCloud9Repo --repository-description "This is a demonstration repository for the AWS Cloud9 sample." --region us-east-2
```
Nel comando precedente, sostituisci `us-east-2` con l'ID della Regione AWS in cui creare il repository. Per un elenco delle regioni supportate, [AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region)consulta. *Riferimenti generali di Amazon Web Services*
Se si sceglie di usare un nome repository diverso, sostituirlo in tutto l'esempio.
## Fase 3: connettere l'ambiente al repository remoto
In questo passaggio, si utilizza l' AWS Cloud9 IDE per connettersi al CodeCommit repository creato o identificato nel passaggio precedente.
**Nota**
Se preferisci utilizzare Git tramite un'interfaccia visiva, puoi clonare il repository remoto. Quindi, puoi aggiungere i file usando la funzionalità del [pannello Git](source-control-gitpanel.md) disponibile nell'IDE.
Completa una delle seguenti procedure, a seconda del tipo di ambiente di sviluppo AWS Cloud9 in uso.
****
| **Tipo di ambiente** | **Completa queste procedure** |
| --- | --- |
| Ambiente EC2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/sample-codecommit.html) |
| Ambiente SSH | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/sample-codecommit.html) |
## Fase 4: clonare il repository remoto nell'ambiente
In questo passaggio, si utilizza l' AWS Cloud9 IDE per clonare l'archivio remoto CodeCommit nel proprio ambiente.
Per clonare il repository, esegui il comando **`git clone`**. Sostituisci `CLONE_URL` con l'URL del clone del repository.
```
git clone CLONE_URL
```
Per un ambiente EC2 è sufficiente specificare un URL clone HTTPS che inizia con `https://`. Per un ambiente SSH è sufficiente specificare un URL clone SSH che inizia con `ssh://`.
*Per ottenere l'URL completo del clone del repository, consulta [Utilizzare la AWS CodeCommit console per visualizzare i dettagli del repository nella Guida per](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-view-repository-details.html#how-to-view-repository-details-console) l'utente.AWS CodeCommit *
Se il repository non contiene file, viene visualizzato un messaggio di avviso come il seguente `You appear to have cloned an empty repository.` Questo è il comportamento previsto che verrà trattato in seguito.
## Fase 5: aggiungere file al repository
In questa fase si devono creare tre file semplici nel repository clonato nell'ambiente AWS Cloud9 . Successivamente, aggiungi i file all'area di gestione temporanea Git del repository clonato. Infine, esegui il commit dei file staged e inserisci il commit nel tuo repository remoto. CodeCommit
Se il repository di cui è stato eseguito il clone dispone già di file, hai terminato l'operazione e puoi ignorare la parte restante dell'esempio.
**Per aggiungere file al repository**
1. Crea un nuovo file. Nella barra dei menu, seleziona **File**, **New File (Nuovo file)**.
1. Immettete il seguente contenuto nel file, quindi scegliete **File**, **Salva per salvare** il file così com'era `bird.txt` nella `MyDemoCloud9Repo` directory del vostro AWS Cloud9 ambiente.
```
bird.txt
--------
Birds are a group of endothermic vertebrates, characterized by feathers,
toothless beaked jaws, the laying of hard-shelled eggs, a high metabolic
rate, a four-chambered heart, and a lightweight but strong skeleton.
```
**Nota**
Nella finestra di dialogo **Save As** (Salva con nome), seleziona la cartella `MyDemoCloud9Repo` per verificare che il file sia stato salvato nella directory corretta. Quindi, assicurati che sia visualizzata la **cartella** `/MyDemoCloud9Repo`.
1. Crea altri due file, denominati `insect.txt` e `reptile.txt`, con il seguente contenuto. Salva i file nella stessa directory `MyDemoCloud9Repo`.
```
insect.txt
----------
Insects are a class of invertebrates within the arthropod phylum that
have a chitinous exoskeleton, a three-part body (head, thorax, and abdomen),
three pairs of jointed legs, compound eyes, and one pair of antennae.
```
```
reptile.txt
-----------
Reptiles are tetrapod (four-limbed vertebrate) animals in the class
Reptilia, comprising today's turtles, crocodilians, snakes,
amphisbaenians, lizards, tuatara, and their extinct relatives.
```
1. Nel terminale, esegui il comando **`cd`** per passare alla directory `MyDemoCloud9Repo`.
```
cd MyDemoCloud9Repo
```
1. Verifica che i file siano stati salvati nella directory `MyDemoCloud9Repo` eseguendo il comando **`git status`**. Tutti e tre file saranno elencati come file non tracciati.
```
Untracked files:
(use "git add ..." to include in what will be committed)
bird.txt
insect.txt
reptile.txt
```
1. Aggiungi i file all'area di gestione temporanea di Git eseguendo il comando **`git add`**.
```
git add --all
```
1. Verifica che i file siano stati aggiunti all'area di gestione temporanea di Git eseguendo di nuovo il comando **`git status`**. Tutti e tre i file sono ora elencati come modifiche per cui eseguire il commit.
```
Changes to be committed:
(use "git rm --cached ..." to unstage)
new file: bird.txt
new file: insect.txt
new file: reptile.txt
```
1. Esegui il commit dei file di gestione temporanea eseguendo il comando **`git commit`**.
```
git commit -m "Added information about birds, insects, and reptiles."
```
1. Inserisci il commit nel tuo repository remoto CodeCommit eseguendo il **`git push`**comando.
```
git push -u origin master
```
1. Conferma la trasmissione dei file. Apri la CodeCommit console, se non è già aperta, in [https://console.aws.amazon.com/codecommitt.](https://console.aws.amazon.com/codecommit)
1. Nella barra di navigazione in alto, vicino al bordo destro, scegli Regione AWS dove hai creato il repository (ad esempio, **Stati Uniti orientali (Ohio**)).
1. **Nella pagina **Dashboard**, scegli MyDemoCloud 9Repo.** I tre file vengono visualizzati.
*Per continuare a sperimentare con il tuo CodeCommit repository, consulta [Sfogliare i contenuti del tuo repository](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse) nella Guida per l'utente.AWS CodeCommit *
[Se sei alle prime armi Git e non vuoi rovinare il tuo CodeCommit repository, prova con un repository di esempio Git sul sito web di Try. Git](https://try.github.io/)
## Fase 6: pulizia
Per evitare addebiti continui a tuo carico Account AWS dopo aver finito di usare questo esempio, elimina il repository. CodeCommit Per istruzioni, consulta [Eliminare un AWS CodeCommit archivio nella Guida](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html) per l'*AWS CodeCommit utente*.
Assicurati di eliminare anche l'ambiente. Per istruzioni, consultare [Deleting an Environment (Eliminazione di un ambiente)](delete-environment.md).
# Tutorial su Amazon DynamoDB per AWS Cloud9
Questo tutorial ti consente di configurare un ambiente di AWS Cloud9 sviluppo per lavorare con Amazon DynamoDB.
DynamoDB è un servizio di database NoSQL completamente gestito. Puoi utilizzare DynamoDB per creare una tabella di database in grado di archiviare e recuperare qualunque quantità di dati e soddisfare qualsiasi livello di traffico di richiesto. DynamoDB distribuisce automaticamente i dati e il traffico per la tabella su un numero di server sufficiente per gestire la capacità di richieste specificata e la quantità di dati archiviati, garantendo al contempo prestazioni rapide e costanti. Per ulteriori informazioni, consulta [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) sul sito Web. AWS
La creazione di questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e DynamoDB. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Per informazioni sulle offerte di AWS database aggiuntive, consulta [Amazon Relational Database Service (](https://aws.amazon.com/rds/)RDS) ElastiCache, [Amazon e [Amazon](https://aws.amazon.com/redshift/) Redshift](https://aws.amazon.com/elasticache/) sul sito Web. AWS Consulta anche [AWS Database Migration Service](https://aws.amazon.com/dms/) sul sito Web AWS .
+ [Prerequisiti](#sample-dynamodb-prereqs)
+ [Fase 1: installare e configurare AWS CLI, AWS CloudShell o entrambe nell'ambiente](#sample-dynamodb-cli-setup)
+ [Fase 2: creare una tabella](#sample-dynamodb-create-table)
+ [Fase 3: aggiungere un elemento alla tabella](#sample-dynamodb-add-item)
+ [Fase 4: aggiungere più elementi alla tabella](#sample-dynamodb-add-items)
+ [Fase 5: creare un indice secondario globale](#sample-dynamodb-create-index)
+ [Fase 6: recuperare elementi dalla tabella](#sample-dynamodb-get-items)
+ [Fase 7: pulire](#sample-dynamodb-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo EC2 esistente AWS Cloud9 .** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Passaggio 1: installa e configura il AWS CLI AWS CloudShell, il o entrambi nel tuo ambiente
In questo passaggio, si utilizza l' AWS Cloud9 IDE per installare e configurare il AWS CLI AWS CloudShell, il o entrambi nel proprio ambiente in modo da poter eseguire comandi per interagire con DynamoDB. Quindi si utilizza AWS CLI per eseguire un comando DynamoDB di base per testare l'installazione e la configurazione.
1. Per configurare la gestione delle credenziali per l' AWS CLI o il AWS CloudShell e installare il AWS CLI AWS CloudShell, il o entrambi nell'ambiente, segui i passaggi 1 e 2 nell'[AWS CloudShell esempio AWS CLI and](sample-aws-cli.md), quindi torna a questo argomento. Se avete già installato e configurato il AWS CLI AWS CloudShell, il o entrambi nel vostro ambiente, non è necessario farlo di nuovo.
1. Verifica l'installazione e la configurazione di AWS CLI, della aws-shell o di entrambe eseguendo il **`list-tables`**comando DynamoDB da una sessione di terminale nel tuo ambiente per elencare le tabelle DynamoDB esistenti, se presenti. Per avviare una nuova sessione del terminale, nella barra dei menu seleziona **Windows** (Finestre), **New Terminal** (Nuovo terminale).
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**Nota**
In questo esempio, se stai utilizzando l'aws-shell, ometti `aws` da ogni comando che inizia con `aws`. Per avviare l'aws-shell, esegui il comando ** `aws-shell` **. Per interrompere l'utilizzo dell'aws-shell, esegui il comando ** `.exit` ** o ** `.quit` **.
Se il comando viene eseguito correttamente, restituisce un array `TableNames` contenente un elenco delle tabelle DynamoDB esistenti che potresti già avere. Se non disponi ancora di tabelle DynamoDB, l'array `TableNames` sarà vuoto.
```
{
"TableNames": []
}
```
Se disponi di tabelle DynamoDB, l'array `TableNames` contiene un elenco dei nomi delle tabelle.
## Fase 2: creazione di una tabella
In questo fase si crea una tabella in DynamoDB e ne specifichi il nome, il layout, la chiave primaria semplice e le impostazioni della velocità effettiva dei dati.
Questa tabella di esempio, denominata `Weather`, contiene informazioni sulle previsioni meteorologiche per alcune città negli Stati Uniti. La tabella contiene i seguenti tipi di informazioni (in DynamoDB, ogni informazione è nota come *attributo*):
+ ID univoco della città richiesto (`CityID`)
+ Data di previsione richiesta (`Date`)
+ Nome della città (`City`)
+ Nome dello stato (`State`)
+ Previsione delle condizioni meteorologiche (`Conditions`)
+ Previsione delle temperature (`Temperatures`)
+ Previsione elevate, in gradi Fahrenheit (`HighF`)
+ Previsione basse, in gradi Fahrenheit (`LowF`)
Per creare la tabella, in una sessione terminale nell' AWS Cloud9 IDE, esegui il comando **`create-table`**DynamoDB.
```
aws dynamodb create-table \
--table-name Weather \
--attribute-definitions \
AttributeName=CityID,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema \
AttributeName=CityID,KeyType=HASH AttributeName=Date,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
In questo comando:
+ `--table-name` rappresenta il nome della tabella (`Weather` in questo esempio). I nomi delle tabelle devono essere univoci all'interno di ogni AWS regione dell'account AWS .
+ `--attribute-definitions` rappresenta gli attributi utilizzati per individuare in modo univoco gli item della tabella. Ogni item della tabella è individuato in modo univoco da una combinazione di un attributo `ID` numerico e un attributo `Date` rappresentato da una stringa nel formato ISO-8601.
+ `--key-schema` rappresenta lo schema della chiave della tabella. Questa tabella dispone di una chiave primaria composita: `CityID` e `Date`. Ciò significa che ciascuno degli item della tabella deve avere un valore degli attributi `CityID` e `Date`, ma nessuno dei valori degli attributi `CityID` e `Date` può coincidere per due item diversi.
+ `--provisioned-throughput` rappresenta la capacità di lettura-scrittura della tabella. DynamoDB permette un massimo di 5 letture fortemente consistenti al secondo per elementi di dimensioni massime pari a 4 KB oppure un massimo di 5 letture consistenti finali al secondo per elementi di dimensioni massime pari a 4 KB. DynamoDB permette anche fino a 5 scritture al secondo per elementi di dimensioni massime pari a 1 KB.
**Nota**
L'impostazione di un throughput assegnato più elevato potrebbe comportare costi aggiuntivi per l'account AWS .
Per ulteriori informazioni su questo e altri comandi DynamoDB, consulta [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html) nella *documentazione di riferimento ai comandi AWS CLI *.
Se questo comando viene eseguito correttamente, vengono visualizzate le informazioni di riepilogo sulla nuova tabella in fase di creazione. Per confermare la corretta creazione della tabella, esegui il comando ** `describe-table` ** di DynamoDB, specificando il nome della tabella (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Una volta creata correttamente la tabella, il valore `TableStatus` cambia da `CREATING` a `ACTIVE`. Non procedere oltre questa fase finché la tabella non è stata creata correttamente.
## Fase 3: aggiungere un elemento alla tabella
In questa fase, aggiungi un item alla tabella appena creata.
1. Crea un archivio denominato `weather-item.json` con i seguenti contenuti. Per creare un nuovo file, nella barra dei menu seleziona **File**, **New File (Nuovo file)**. Per salvare il file, seleziona **File**, **Save (Salva)**.
```
{
"CityID": { "N": "1" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "46" }
}
}
}
```
In questo codice, `N` rappresenta un valore di attributo che è un numero. `S` è un valore di attributo della stringa. `M` è un attributo di mappa, che è un insieme di coppie attributo-valore. Quando lavori con gli item, devi specificare un tipo di dati per gli attributi. Per ulteriori tipi di dati degli attributi, consulta [Tipi di dati](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) nella *Guida per gli sviluppatori di Amazon DynamoDB*.
1. Esegui il comando ** `put-item` ** di DynamoDB, specificando il nome della tabella (`--table-name`) e il percorso dell'elemento in formato JSON (`--item`).
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
Se il comando viene eseguito correttamente, senza errori e non viene visualizzato alcun messaggio di conferma.
1. Per verificare i contenuti correnti della tabella, esegui il comando ** `scan` ** di DynamoDB, specificando il nome della tabella (`--table-name`).
```
aws dynamodb scan --table-name Weather
```
Se il comando viene eseguito correttamente, vengono visualizzate le informazioni sulla tabella e sull'item appena aggiunto.
## Fase 4: aggiungere più elementi alla tabella
In questa fase, aggiungi ulteriori item alla tabella `Weather`.
1. Crea un archivio denominato `more-weather-items.json` con i seguenti contenuti.
```
{
"Weather": [
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "52" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Thunderstorms" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "51" },
"LowF": { "N": "41" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain Showers" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "39" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "40" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Partly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "54" },
"LowF": { "N": "37" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Mostly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "53" },
"LowF": { "N": "37" }
}
}
}
}
}
]
}
```
In questo codice, 8 oggetti `Item` definiscono gli 8 item da aggiungere alla tabella, simili al singolo item definito nella fase precedente. Tuttavia, quando esegui il comando ** `batch-write-item` ** di DynamoDB nella fase successiva, devi fornire un oggetto in formato JSON che includa ogni oggetto `Item` in un oggetto `PutRequest`. Quindi devi includere tali oggetti `PutRequest` in un array padre che abbia lo stesso nome della tabella.
1. Esegui il comando ** `batch-write-item` ** di DynamoDB, specificando il percorso degli elementi in formato JSON da aggiungere (`--request-items`).
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
Se il comando viene eseguito correttamente, viene visualizzato il messaggio seguente, a conferma che gli item sono stati aggiunti correttamente.
```
{
"UnprocessedItems": {}
}
```
1. Per confermare i contenuti correnti della tabella, esegui di nuovo il comando ** `scan` ** di DynamoDB.
```
aws dynamodb scan --table-name Weather
```
Se il comando viene eseguito correttamente, adesso sono visualizzati 9 item.
## Fase 5: creare un indice secondario globale
L'esecuzione del comando ** `scan` ** di DynamoDB per ottenere le informazioni sulle voci può risultare un'operazione lenta, specialmente quando le dimensioni di una tabella aumentano o se il tipo di informazioni da ottenere è complesso. Per velocizzare l'operazione e rendere più semplice il recupero delle informazioni, puoi creare uno o più indici secondari. In questa fase sono illustrati due tipi di indici secondari supportati da DynamoDB a tale scopo. Si tratta dell'*indice secondario locale* e dell'*indice secondario globale*. Quindi, potrai creare un indice secondario globale.
Per comprendere questi tipi di indice secondario, devi prima conoscere le chiavi primarie, che identificano in modo univoco gli elementi di una tabella. DynamoDB supporta una *chiave primaria semplice* o una *chiave primaria composita*. Una chiave primaria semplice dispone di un singolo attributo, il cui valore deve essere univoco per ogni item della tabella. Questo attributo è noto anche come *chiave di partizione* (o *attributo hash*), che DynamoDB può utilizzare per eseguire una partizione degli elementi per accelerare l'accesso. Una tabella può inoltre avere una chiave primaria composita, che contiene due attributi. Il primo attributo è la chiave di partizione e il secondo è una *chiave di ordinamento* (nota anche come *attributo di intervallo*). In una tabella con una chiave primaria composita, due item possono avere lo stesso valore della chiave di partizione, ma non anche lo stesso valore della chiave di ordinamento. La tabella `Weather` dispone di una chiave primaria composita.
Un indice secondario locale ha la medesima chiave di partizione della tabella, ma questo tipo di indice può avere una chiave di ordinamento diversa. Un indice secondario globale può avere una chiave di partizione e una chiave di ordinamento entrambe diverse dalla tabella.
Ad esempio, puoi già utilizzare la chiave primaria per accedere agli item di `Weather` per `CityID`. Per accedere agli item di `Weather` per `State`, puoi creare un indice secondario locale con la stessa chiave di partizione di `CityID` (deve essere lo stesso della tabella) e una chiave di ordinamento di `State`. Per accedere agli item di `Weather` per `City`, puoi creare un indice secondario globale con una chiave di partizione di `City` e una chiave di ordinamento di `Date`.
Puoi creare indici secondari locali solo durante la creazione di una tabella. Poiché la tabella `Weather` esiste già, non puoi aggiungervi alcun indice secondario locale, ma puoi aggiungervi degli indici secondari globali. Prova ad aggiungerne uno adesso.
**Nota**
La creazione di indici secondari potrebbe comportare ulteriori addebiti sull'account AWS .
1. Crea un archivio denominato `weather-global-index.json` con i seguenti contenuti.
```
[
{
"Create": {
"IndexName": "weather-global-index",
"KeySchema": [
{
"AttributeName": "City",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"State",
"Conditions",
"Temperatures"
]
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
}
}
}
]
```
In questo codice:
+ Il nome dell'indice secondario globale è `weather-global-index`.
+ L'attributo `City` è la chiave di partizione (attributo hash) e l'attributo `Date` è la chiave di ordinamento (attributo di intervallo).
+ `Projection` definisce gli attributi da recuperare per impostazione predefinita (oltre all'attributo hash e a qualsiasi attributo di intervallo) per ogni item che corrisponde a una ricerca nella tabella che utilizza questo indice. In questo esempio, gli attributi `State`, `Conditions`, `HighF` (parte di `Temperatures`) e `LowF` (parte di `Temperatures`) (oltre agli attributi `City` e `Date`) vengono recuperati per ogni item corrispondente.
+ Analogamente alle tabelle, un indice secondario globale deve definire le relative impostazioni per il throughput assegnato.
+ Le impostazioni `IndexName`, `KeySchema`, `Projection` e `ProvisionedThroughput` devono essere contenute in un oggetto `Create`, che definisce l'indice secondario globale da creare quando si esegue il comando** `update-table` **di DynamoDB nella fase successiva.
1. Esegui il comando ** `update-table` ** di DynamoDB.
```
aws dynamodb update-table \
--table-name Weather \
--attribute-definitions \
AttributeName=City,AttributeType=S AttributeName=Date,AttributeType=S \
--global-secondary-index-updates file://weather-global-index.json
```
In questo comando:
+ `--table-name` è il nome della tabella da aggiornare.
+ `--attribute-definitions` sono gli attributi da includere nell'indice. La chiave di partizione è sempre elencati per prima e qualsiasi chiave di ordinamento è sempre elencata per seconda.
+ `--global-secondary-index-updates` è il percorso del file che definisce l'indice secondario globale.
Se questo comando viene eseguito correttamente, vengono visualizzate le informazioni di riepilogo sul nuovo indice secondario globale in fase di creazione. Per confermare la corretta creazione dell'indice secondario globale, esegui il comando ** `describe-table` ** di DynamoDB, specificando il nome della tabella (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Una volta creato correttamente l'indice secondario globale, il valore di `TableStatus` cambia da `UPDATING` a `ACTIVE` e il valore di `IndexStatus` da `CREATING` a `ACTIVE`. Non procedere oltre questa fase finché l'indice secondario globale non è stato creato correttamente. Questo processo può richiedere diversi minuti.
## Fase 6: ottenere elementi dalla tabella
Esistono molti modi per ottenere gli item dalle tabelle. In questa fase, otterrai gli item utilizzando la chiave primaria e gli altri attributi della tabella e utilizzando l'indice secondario globale.
### Per ottenere un singolo item da una tabella in base al valore della chiave primaria dell'item
Se conosci il valore della chiave primaria di elemento, puoi ottenere l'elemento corrispondente eseguendo i comandi ** `get-item` **, ** `scan` ** o ** `query` **. Di seguito sono elencate le principali differenze tra questi comandi:
+ ** `get-item` ** restituisce un insieme di attributi della voce con la chiave primaria indicata.
+ ** `scan` ** restituisce una o più voci e i relativi attributi accedendo a ogni voce in una tabella o un indice secondario.
+ ** `query` ** rileva le voci in base ai valori della chiave primaria. Puoi eseguire una query su qualsiasi tabella o indice secondario che abbia una chiave primaria composita (una chiave di partizione e una chiave di ordinamento).
In questo esempio, ti mostriamo come utilizzare ciascuno di questi comandi per ottenere l'item che contiene il valore `CityID` dell'attributo `1` e il valore `Date` dell'attributo `2017-04-12`.
1. Per eseguire il comando ** `get-item` ** di DynamoDB, specifica il nome della tabella (`--table-name`), il valore della chiave primaria (`--key`) e i valori degli attributi dell'elemento da visualizzare (`--projection-expression`). Poiché `Date` è una parola chiave riservata in DynamoDB, devi fornire anche un alias per il valore di attributo `Date` (`--expression-attribute-names`) (anche `State` è una parola chiave riservata, quindi ne visualizzerai un alias nelle fasi successive).
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }' \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
In questo e negli altri comandi, per visualizzare tutti gli attributi dell'item, non includere `--projection-expression`. In questo esempio, dato che non stai includendo `--projection-expression` non hai bisogno di includere neanche `--expression-attribute-names`.
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. Per eseguire il comando** `scan` ** di DynamoDB, specifica:
+ Nome della tabella (`--table-name`).
+ Ricerca da eseguire (`--filter-expression`).
+ Criteri di ricerca da utilizzare (`--expression-attribute-values`).
+ Tipi di attributi da visualizzare per l'item corrispondente (`--select`).
+ Valori degli attributi per l'item da visualizzare (`--projection-expression`).
+ Se qualcuno degli attributi utilizza parole chiave riservate in DynamoDB, per quegli attributi saranno impiegati degli alias (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
1. Per eseguire il comando** `query` ** di DynamoDB, specifica:
+ Nome della tabella (`--table-name`).
+ Ricerca da eseguire (`--key-condition-expression`).
+ Valori degli attributi da utilizzare nella ricerca (`--expression-attribute-values`).
+ Tipi di attributi da visualizzare per l'item corrispondente (`--select`).
+ Valori degli attributi per l'item da visualizzare (`--projection-expression`).
+ Se qualcuno degli attributi utilizza parole chiave riservate in DynamoDB, per quegli attributi saranno impiegati degli alias (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--key-condition-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
Nota che il comando ** `scan` ** ha dovuto eseguire la scansione di tutte e 9 le voci per ottenere il risultato, mentre il comando ** `query` ** ha dovuto eseguire la scansione solo di 1 voce.
### Per ottenere più item da una tabella in base ai valori della relativa chiave primaria
Se conosci i valori della chiave primaria delle voci, puoi ottenere gli elementi corrispondenti eseguendo il comando ** `batch-get-item` ** di DynamoDB. In questo esempio, ecco come puoi ottenere gli item che contengono il valore `CityID` dell'attributo `3` e i valori `Date` o `2017-04-13` dell'attributo `2017-04-14`.
Esegui il comando ** `batch-get-item` ** di DynamoDB, specificando il percorso di un file che descrive gli elementi da ottenere (`--request-items`).
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
Per questo esempio, il codice nel file `batch-get-item.json` specifica di ricercare nella tabella `Weather` gli item con `CityID` `3` e con `Date` `2017-04-13` o `2017-04-14`. Per ogni item individuato, vengono visualizzati i valori degli attributi `City`, `State`, `Date` e `HighF` (parte di `Temperatures`), se esistenti.
```
{
"Weather" : {
"Keys": [
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" }
},
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" }
}
],
"ProjectionExpression": "City, #S, #D, Temperatures.HighF",
"ExpressionAttributeNames": { "#S": "State", "#D": "Date" }
}
}
```
### Per ottenere tutti gli item corrispondenti da una tabella
Se conosci i valori degli attributi nella tabella, puoi ottenere gli elementi corrispondenti eseguendo il comando ** `scan` ** di DynamoDB. In questo esempio, ecco come puoi ottenere le date se il valore dell'attributo `Conditions` contiene `Sunny` e il valore dell'attributo `HighF` (parte di `Temperatures`) è superiore a `53`.
Esegui il comando ** `scan` ** di DynamoDB, specificando:
+ Nome della tabella (`--table-name`).
+ Ricerca da eseguire (`--filter-expression`).
+ Criteri di ricerca da utilizzare (`--expression-attribute-values`).
+ Tipi di attributi da visualizzare per l'item corrispondente (`--select`).
+ Valori degli attributi per l'item da visualizzare (`--projection-expression`).
+ Se qualcuno degli attributi utilizza parole chiave riservate in DynamoDB, per quegli attributi saranno impiegati degli alias (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression \
"(contains (Conditions, :sun)) and (Temperatures.HighF > :h)" \
--expression-attribute-values \
'{ ":sun": { "S" : "Sunny" }, ":h": { "N" : "53" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
### Per ottenere tutti gli item corrispondenti da un indice secondario globale
Per eseguire la ricerca utilizzando un indice secondario globale, utilizza il comando ** `query` ** di DynamoDB. In questo esempio, ecco come puoi utilizzare l'indice secondario `weather-global-index` per ottenere le previsioni delle città denominate `Portland` per le date `2017-04-13` e `2017-04-14`.
Esegui il comando ** `query` ** di DynamoDB, specificando:
+ Nome della tabella (`--table-name`).
+ Nome dell'indice secondario globale (`--index-name`).
+ Ricerca da eseguire (`--key-condition-expression`).
+ Valori degli attributi da utilizzare nella ricerca (`--expression-attribute-values`).
+ Tipi di attributi da visualizzare per l'item corrispondente (`--select`).
+ Se qualcuno degli attributi utilizza parole chiave riservate in DynamoDB, per quegli attributi saranno impiegati degli alias (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--index-name weather-global-index \
--key-condition-expression "(City = :city) and (#D between :date1 and :date2)" \
--expression-attribute-values \
'{ ":city": { "S" : "Portland" }, ":date1": { "S": "2017-04-13" }, ":date2": { "S": "2017-04-14" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
## Fase 7: pulire
Per evitare addebiti continui AWS sul tuo account dopo aver utilizzato questo esempio, dovresti eliminare la tabella. Eliminando la tabella viene eliminato anche l'indice secondario globale. Devi eliminare anche l'ambiente.
Per eliminare la tabella, esegui il comando ** `delete-table` ** di DynamoDB, specificando il nome della tabella (`--table-name`).
```
aws dynamodb delete-table --table-name Weather
```
Se il comando viene eseguito correttamente, vengono visualizzate le informazioni sulla tabella, incluso il valore `TableStatus` di `DELETING`.
Per confermare la corretta eliminazione della tabella, esegui il comando ** `describe-table` ** di DynamoDB, specificando il nome della tabella (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Se la tabella viene eliminata correttamente, viene visualizzato un messaggio contenente la frase `Requested resource not found` (Risorsa richiesta non trovata).
Per eliminare l'ambiente, consulta [Eliminazione di un ambiente](delete-environment.md).
# AWS CDK tutorial per AWS Cloud9
Questo tutorial mostra come utilizzarli AWS Cloud Development Kit (AWS CDK) in un ambiente di AWS Cloud9 sviluppo. AWS CDK Si tratta di un insieme di strumenti software e librerie che gli sviluppatori possono utilizzare per modellare i componenti AWS dell'infrastruttura sotto forma di codice.
AWS CDK Include la AWS Construct Library che è possibile utilizzare per risolvere rapidamente molte attività. AWS Ad esempio, è possibile utilizzare il costrutto `Fleet` per distribuire in modo sicuro e completo il codice a un parco di host. È possibile creare i propri costrutti per modellare vari elementi delle proprie architetture, condividerli con altri utenti o pubblicarli per la community. Per ulteriori informazioni, consulta la [Guida per sviluppatori AWS Cloud Development Kit](https://docs.aws.amazon.com/cdk/v2/guide/home.html).
L'esecuzione di questo tutorial e la creazione di questo esempio potrebbero comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2, Amazon SNS e Amazon SQS. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/), [Prezzi di Amazon SNS](https://aws.amazon.com/sns/pricing/) e [Prezzi di Amazon SQS Gateway](https://aws.amazon.com/sqs/pricing/).
**Topics**
+ [Prerequisiti](#sample-cdk-prereqs)
+ [Fase 1: installare gli strumenti necessari](#sample-cdk-install)
+ [Fase 2: aggiungere un codice](#sample-cdk-code)
+ [Fase 3: eseguire il codice](#sample-cdk-run)
+ [Fase 4: pulizia](#sample-cdk-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare gli strumenti necessari
In questo passaggio, installate tutti gli strumenti dell'ambiente AWS CDK necessari per eseguire un esempio scritto nel linguaggio di TypeScript programmazione.
1. [Node Version Manager](#sample-cdk-install-nvm) o ** `nvm`**, che consentono di installare Node.js in un momento successivo.
1. [Node.js](#sample-cdk-install-nodejs), che è richiesto dall'esempio e contiene Node Package Manager, oppure **`npm`**, che viene utilizzato per l'installazione TypeScript e AWS CDK versioni successive.
1. [TypeScript](#sample-cdk-install-typescript), richiesto da questo esempio. (Fornisce AWS CDK inoltre supporto per diversi altri linguaggi di programmazione.)
1. [AWS CDK](#sample-cdk-install-cdk).
### Fase 1.1: installare Node Version Manager (nvm)
1. In una sessione terminale nell' AWS Cloud9 IDE, assicuratevi che siano installati gli ultimi aggiornamenti di sicurezza e le correzioni dei bug. A tale scopo, esegui il comando ** `yum update` ** (per Amazon Linux) o ** `apt update` ** (per Ubuntu Server). Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale).
Per Amazon Linux:
```
sudo yum -y update
```
Per Ubuntu Server:
```
sudo apt update
```
1. Confermare se ** `nvm` ** è già installato. A tale scopo, eseguire il comando ** `nvm` ** con l'opzione ** `--version` **.
```
nvm --version
```
Se l'operazione è andata a buon fine, l'output contiene il numero di versione ** `nvm` ** ed è possibile passare a [Fase 1.2: installare Node.js](#sample-cdk-install-nodejs).
1. Scaricare e installare ** `nvm` **. Per fare ciò, eseguire lo script di installazione. In questo esempio, v0.33.0 è installato, ma è possibile verificare la versione più recente di ** `nvm` ** [qui](https://github.com/nvm-sh/nvm#installing-and-updating).
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Iniziare a usare ** `nvm` **. È possibile chiudere la sessione del terminale per poi riavviarla oppure trovare il file `~/.bashrc` che contiene i comandi per caricare ** `nvm` **.
```
. ~/.bashrc
```
### Fase 1.2: installare Node.js
1. Confermare se Node.js è già installato e, in caso affermativo, confermare che la versione installata è la 16.17.0 o superiore. **Questo esempio è stato testato con Node.js 16.17.0.** Per controllare, con la sessione del terminale ancora aperta nell'IDE, esegui il comando ** `node` ** con l'opzione ** `--version` **.
```
node --version
```
Se Node.js è già installato, l'output includerà il numero di versione. Se il numero di versione è v16.17.0, passare a [Passaggio 1.3: Installazione TypeScript](#sample-cdk-install-typescript).
1. Installa Node.js 16 eseguendo il **`nvm`**comando con l'**`install`**azione.
**Nota**
Puoi anche **`nvm install node`**eseguire l'installazione della versione LTS (Long-Term Support) di Node.js. AWS Cloud9 support tiene traccia della versione LTS di Node.js.
```
nvm install v16
```
1. Inizia a usare Node.js 16. A tale scopo, eseguire il comando ** `nvm` ** con l'operazione ** `alias` **, il numero di versione dell'alias e la versione da utilizzare per quell'alias, come descritto di seguito.
```
nvm alias default 16
```
**Nota**
Il comando precedente imposta Node.js 16 come versione predefinita di Node.js. In alternativa, è possibile eseguire il comando ** `nvm` ** con l'operazione ** `use` ** anziché l'operazione ** `alias` ** (ad esempio, ** `nvm use 16.17.0` **). Tuttavia, l'operazione ** `use` ** fa sì che quella versione di Node.js sia eseguita solo durante l'attuale sessione del terminale.
1. Per confermare che stai usando Node.js 16, esegui nuovamente il **`node --version`**comando. Se è installata la versione corretta, l'output contiene la versione v16.
### Passaggio 1.3: Installazione TypeScript
1. Conferma se l'hai già TypeScript installato. Per fare ciò, con la sessione di terminale ancora aperta nell'IDE, esegui il TypeScript compilatore a riga di comando con l'**`--version`**opzione.
```
tsc --version
```
Se l'avete TypeScript installato, l'output contiene il numero di TypeScript versione. Se TypeScript è installato, vai avanti a[Fase 1.4: Installare AWS CDK](#sample-cdk-install-cdk).
1. Installa TypeScript. A tale scopo, esegui il **`npm`**comando con l'**`install`**azione, **`-g`**l'opzione e il nome del TypeScript pacchetto. Si installa TypeScript come pacchetto globale nell'ambiente.
```
npm install -g typescript
```
1. Conferma che TypeScript sia installato. Per fare ciò, esegui il TypeScript compilatore a riga di comando con l'**`--version`**opzione.
```
tsc --version
```
Se TypeScript è installato, l'output contiene il numero di TypeScript versione.
### Fase 1.4: Installare AWS CDK
1. Conferma se hai già AWS CDK installato il file. A tale scopo, con la sessione del terminale ancora aperta nell'IDE, esegui il comando ** `cdk` ** con l'opzione ** `--version` **.
```
cdk --version
```
Se AWS CDK è installato, l'output contiene la AWS CDK versione e i numeri di build. Passare direttamente a [Fase 2: aggiungere un codice](#sample-cdk-code).
1. Installalo AWS CDK eseguendo il **`npm`**comando insieme all'`install`azione, al nome del AWS CDK pacchetto da installare e all'`-g`opzione per installare il pacchetto a livello globale nell'ambiente.
```
npm install -g aws-cdk
```
1. Verificate che AWS CDK sia installato e che vi sia un riferimento corretto. A tale scopo, eseguire il comando ** `cdk` ** con l'opzione ** `--version` **.
```
cdk --version
```
In caso di successo, vengono visualizzati i numeri di AWS CDK versione e build.
## Fase 2: aggiungere un codice
In questo passaggio, crei un TypeScript progetto di esempio che contiene tutto il codice sorgente necessario per distribuire uno AWS CDK stack a livello di codice. AWS CloudFormation Questo stack crea un argomento Amazon SNS e una coda Amazon SQS nel AWS tuo account, quindi sottoscrive la coda all'argomento.
1. Con la sessione del terminale ancora aperta nell'IDE, crea una directory in cui salvare il codice sorgente del progetto, ad esempio una directory `~/environment/hello-cdk` nell'ambiente. Quindi passare a tale directory.
```
rm -rf ~/environment/hello-cdk # Remove this directory if it already exists.
mkdir ~/environment/hello-cdk # Create the directory.
cd ~/environment/hello-cdk # Switch to the directory.
```
1. Configura la directory come progetto linguistico per. TypeScript AWS CDK A tale scopo, esegui il comando ** `cdk` ** con l'operazione ** `init` **, il modello ** `sample-app` ** e l'opzione ** `--language` ** insieme al nome del linguaggio di programmazione.
```
cdk init sample-app --language typescript
```
Così facendo, nella directory vengono creati i seguenti file e le seguenti sottodirectory.
+ Una sottodirectory `.git` nascosta e un file `.gitignore` nascosto, che rendono il progetto compatibile con gli strumenti di controllo del codice sorgente, ad esempio Git.
+ Una sottodirectory `lib` che include un file `hello-cdk-stack.ts`. Questo file contiene il codice per il tuo AWS CDK stack. Questo codice è descritto nella fase successiva in questa procedura.
+ Una sottodirectory `bin` che include un file `hello-cdk.ts`. Questo file contiene il punto di ingresso per AWS CDK l'app.
+ Una sottodirectory `node_modules` che contiene pacchetti di codici di supporto, che l'app e lo stack possono utilizzare laddove necessari.
+ Un file `.npmignore` nascosto in cui sono elencati i tipi di sottodirectory e file di cui ** `npm` ** non necessita quando crea il codice.
+ Un file `cdk.json`, che contiene informazioni per semplificare l'esecuzione del comando ** `cdk` **.
+ Un file `package-lock.json`, che contiene le informazioni che ** `npm` ** può utilizzare per ridurre i possibile errori di creazione ed esecuzione.
+ Un file `package.json`, che contiene informazioni per semplificare l'esecuzione del comando ** `npm` **, riducendo al contempo a minimo gli errori di creazione ed esecuzione.
+ Un `README.md` file, che elenca i comandi utili con cui è possibile eseguire **`npm`**e il AWS CDK.
+ Un file `tsconfig.json`, che contiene informazioni per semplificare l'esecuzione del comando ** `tsc` **, riducendo al contempo a minimo gli errori di creazione ed esecuzione.
1. Nella finestra **Environment (Ambiente)**, aprire il file `lib/hello-cdk-stack.ts` e cercare il seguente codice in quel file.
```
import sns = require('@aws-cdk/aws-sns');
import sqs = require('@aws-cdk/aws-sqs');
import cdk = require('@aws-cdk/cdk');
export class HelloCdkStack extends cdk.Stack {
constructor(parent: cdk.App, name: string, props?: cdk.StackProps) {
super(parent, name, props);
const queue = new sqs.Queue(this, 'HelloCdkQueue', {
visibilityTimeoutSec: 300
});
const topic = new sns.Topic(this, 'HelloCdkTopic');
topic.subscribeQueue(queue);
}
}
```
+ Le `Topic` classi `Stack``App`,`StackProps`,`Queue`, e rappresentano rispettivamente uno CloudFormation stack e le relative proprietà, un programma eseguibile, una coda Amazon SQS e un argomento Amazon SNS.
+ La `HelloCdkStack` classe rappresenta lo CloudFormation stack per questa applicazione. Questa pila contiene la nuova coda Amazon SQS e l'argomento Amazon SNS per questa applicazione.
1. Nella finestra **Environment (Ambiente)**, aprire il file `bin/hello-cdk.ts` e cercare il seguente codice in quel file.
```
#!/usr/bin/env node
import cdk = require('@aws-cdk/cdk');
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack');
app.run();
```
Questo codice carica, crea un'istanza, quindi esegue la classe `HelloCdkStack` dal file `lib/hello-cdk-stack.ts`.
1. **`npm`**Utilizzatelo per eseguire il TypeScript compilatore per verificare la presenza di errori di codifica, quindi abilitatelo AWS CDK per eseguire il file del progetto. `bin/hello-cdk.js` A tale scopo, dalla directory principale, esegui il comando ** `npm` ** con l'operazione ** `run` **, specificando il valore di comando ** `build` ** nel file `package.json`, come descritto di seguito.
```
npm run build
```
Il comando precedente esegue il TypeScript compilatore, che aggiunge file e di supporto. `bin/hello-cdk.d.ts` `lib/hello-cdk-stack.d.ts` Il compilatore, inoltre, esegue il transpiling dei file `hello-cdk.ts` e `hello-cdk-stack.ts` nei file `hello-cdk.js` e `hello-cdk-stack.js`.
## Fase 3: eseguire il codice
In questo passaggio, si ordina di AWS CDK creare un modello di CloudFormation stack basato sul codice contenuto nel file. `bin/hello-cdk.js` Quindi chiedi loro di AWS CDK distribuire lo stack, che crea l'argomento Amazon SNS e la coda Amazon SQS e quindi sottoscrive la coda all'argomento. Quindi confermi che l'argomento e la coda sono stati correttamente distribuiti inviando un messaggio dall'argomento alla coda.
1. AWS CDK Fai CloudFormation in modo che crei il modello di stack. A tale scopo, con la sessione del terminale ancora aperta nell'IDE, dalla directory principale del progetto esegui il comando ** `cdk` ** con l'operazione ** `synth` ** e il nome della pila.
```
cdk synth HelloCdkStack
```
In caso di successo, l'output visualizza la sezione del modello di CloudFormation `Resources` pila.
1. La prima volta che distribuisci un' AWS CDK app in un ambiente per una combinazione specifica di AWS account e AWS regione, devi installare uno *stack di bootstrap*. Questo stack include varie risorse di cui AWS CDK ha bisogno per completare le varie operazioni. Ad esempio, questo stack include un bucket Amazon S3 che AWS CDK viene utilizzato per archiviare modelli e asset durante i processi di distribuzione. Per installare lo stack di bootstrap, eseguire il comando ** `cdk` ** sull'istanza con l'operazione di ** `bootstrap` **.
```
cdk bootstrap
```
**Nota**
Se esegui `cdk bootstrap` senza specificare alcuna opzione, vengono utilizzati l' AWS account e AWS la regione predefiniti. Puoi anche avviare un ambiente specifico specificando un profilo e una combinazione. account/Region Esempio:
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. Fai in modo che AWS CDK esegui il modello di CloudFormation stack per distribuire lo stack. A tale scopo, dalla directory principale del progetto eseguire il comando ** `cdk` ** con l'operazione ** `deploy` ** e il nome dello stack.
```
cdk deploy HelloCdkStack
```
Se l'operazione è andata a buon fine, l'output mostra che lo stack `HelloCdkStack` è stato distribuito senza errori.
**Nota**
Se l'output visualizza un messaggio che indica che lo stack non definisce un ambiente e che AWS le credenziali non possono essere ottenute da posizioni standard o non è stata configurata alcuna regione, assicuratevi che AWS le credenziali siano impostate correttamente nell'IDE, quindi eseguite nuovamente il comando. **`cdk deploy`** Per ulteriori informazioni, consulta [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md).
1. Per confermare che l'argomento Amazon SNS e la coda Amazon SQS sono stati implementati correttamente, invia un messaggio all'argomento, quindi controlla se la coda ha ricevuto il messaggio. A tale scopo, è possibile utilizzare uno strumento come il AWS Command Line Interface (AWS CLI) o il. AWS CloudShell Per ulteriori informazioni su questi strumenti, consulta [AWS CLI e tutorial aws-shell per AWS Cloud9](sample-aws-cli.md).
Ad esempio, per inviare un messaggio all'argomento, con la sessione terminale ancora aperta nell'IDE, usa il AWS CLI **`publish`**comando Amazon SNS, fornendo l'oggetto e il corpo del messaggio, la AWS regione per l'argomento e l'Amazon Resource Name (ARN) dell'argomento.
```
aws sns publish --subject "Hello from the AWS CDK" --message "This is a message from the AWS CDK." --topic-arn arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K
```
Nel comando precedente, sostituite `arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K` con l'ARN assegnato CloudFormation all'argomento. Per ottenere l'ID, puoi eseguire il comando ** `list-topics` ** di Amazon SNS.
```
aws sns list-topics --output table --query 'Topics[*].TopicArn'
```
Se l'operazione è andata a buon fine, l'output del comando ** `publish` ** mostra il valore `MessageId` per il messaggio pubblicato.
Per controllare la coda per il messaggio ricevuto, esegui il comando ** `receive-message` ** di Amazon SQS, indicando l'URL della coda.
```
aws sqs receive-message --queue-url https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K
```
Nel comando precedente, sostituite `https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K` con l'ARN assegnato CloudFormation alla coda. Per ottenere l'URL, puoi eseguire il comando ** `list-queues` ** di Amazon SQS.
```
aws sqs list-queues --output table --query 'QueueUrls[*]'
```
Se l'operazione è andata a buon fine, l'output del comando ** `receive-message` ** mostra le informazioni sul messaggio ricevuto.
## Fase 4: pulizia
Per evitare addebiti continui sul tuo AWS account dopo aver finito di utilizzare questo esempio, dovresti eliminare lo stack. CloudFormation Questo elimina l'argomento Amazon SNS e la coda Amazon SQS. È inoltre necessario eliminare l'ambiente.
### Fase 4.1: eliminare la pila
Con la sessione del terminale ancora aperta nell'IDE, dalla directory principale del progetto esegui il comando ** `cdk` ** con l'operazione ** `destroy` ** e il nome della pila.
```
cdk destroy HelloCdkStack
```
Quando viene richiesto di eliminare lo stack, digita `y`, quindi premi `Enter`.
Se l'operazione è andata a buon fine, l'output mostra che lo stack `HelloCdkStack` è stato eliminato senza errori.
### Fase 4.2: eliminare l'ambiente
Per eliminare l'ambiente, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# Tutorial LAMP per AWS Cloud9
Questo tutorial ti consente di configurare ed eseguire LAMP (Linux, Apache Server HTTP, MySQLe PHP) all'interno di un ambiente di AWS Cloud9 sviluppo.
Seguire questo tutorial e creare questo esempio potrebbe comportare dei costi a carico dell'utente Account AWS. Questi includono eventuali costi per Servizi AWS Amazon Elastic Compute Cloud (Amazon EC2). Per ulteriori informazioni, consulta la pagina [ EC2 dei prezzi di Amazon](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Prerequisiti](#sample-lamp-prereqs)
+ [Fase 1: installare gli strumenti](#sample-lamp-install-tools)
+ [Fase 2: Configurazione MySQL](#sample-lamp-setup-mysql)
+ [Fase 3: configurare un sito Web](#sample-lamp-apache)
+ [Fase 4: pulizia](#sample-lamp-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di AWS Cloud9 EC2 sviluppo esistente.** Questo esempio presuppone che tu disponga già di un EC2 ambiente connesso a un' EC2 istanza Amazon che esegue Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare gli strumenti
In questa fase installi i seguenti strumenti:
+ Apache HTTP Server, un host di server web.
+ PHP, un linguaggio di script che è particolarmente idoneo per lo sviluppo Web e può essere integrato in HTML.
+ MySQL, un sistema di gestione dei database.
Quindi finisci questo passaggio avviando Apache Server HTTP e poi MySQL.
1. Assicurarsi che gli ultimi aggiornamenti di sicurezza e correzioni di bug siano installati nell'istanza. A tale scopo, in una sessione terminale nell' AWS Cloud9 IDE, esegui **`yum update`**for (Amazon Linux) o **`apt update`**for (Ubuntu Comando Server (). Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale).
Per Amazon Linux:
```
sudo yum -y update
```
In Ubuntu Server:
```
sudo apt -y update
```
1. Controlla se Apache Il server HTTP è già installato. A tale scopo, esegui **`httpd -v`**(per Amazon Linux) o **`apache2 -v`**(per Ubuntu comando Server ().
In caso di successo, l'output contiene il Apache Numero di versione del server HTTP.
Se vedi un errore, installa Apache Server HTTP eseguendo il **`install`**comando.
Per Amazon Linux:
```
sudo yum install -y httpd24
```
In Ubuntu Server:
```
sudo apt install -y apache2
```
1. Conferma se PHP è già installato eseguendo il **`php -v`**comando.
Se è già installato, l'output contiene il numero di versione di PHP:
Se viene visualizzato un messaggio di errore, installa PHP eseguendo il comando **`install`**.
Per Amazon Linux:
```
sudo yum install -y php56
```
In Ubuntu Server:
```
sudo apt install -y php libapache2-mod-php php-xml
```
1. Conferma se MySQL è già installato eseguendo il **`mysql --version`**comando.
In caso di successo, l'output contiene il MySQL numero di versione.
Se vedi un errore, installa MySQL eseguendo il **`install`**comando.
Per Amazon Linux:
```
sudo yum install -y mysql-server
```
In Ubuntu Server:
```
sudo apt install -y mysql-server
```
1. Dopo l'installazione Apache Server HTTP, PHPe MySQL, avvia Apache HTTP Server, quindi conferma che è stato avviato, eseguendo il comando seguente.
Per Amazon Linux (potrebbe essere necessario eseguire il comando due volte):
```
sudo service httpd start && sudo service httpd status
```
In Ubuntu Server (per tornare al prompt dei comandi, premere`q`):
```
sudo service apache2 start && sudo service apache2 status
```
1. Start (Avvio) MySQL, quindi conferma che sia stato avviato, eseguendo il comando seguente.
Per Amazon Linux:
```
sudo service mysqld start && sudo service mysqld status
```
In Ubuntu Server (per tornare al prompt dei comandi, premere`q`):
```
sudo service mysql start && sudo service mysql status
```
## Fase 2: Configurazione MySQL
In questo passaggio, si configura MySQL seguire MySQL migliori pratiche di sicurezza. Queste best practice di sicurezza includono l'impostazione di una password per gli account root e la rimozione degli account root accessibili dall'esterno dell'host locale. Altre best practice da tenere in considerazione sono la rimozione degli utenti anonimi, la rimozione del database di test e la rimozione dei privilegi che consentono a chiunque di accedere ai database con i nomi che iniziano con `test_`.
Quindi finisci questo passaggio esercitandoti con l'avvio e poi l'uscita dal MySQL client a riga di comando.
1. Implement MySQL migliori pratiche di sicurezza per MySQL installazione eseguendo il comando seguente in una sessione di terminale nell' AWS Cloud9 IDE.
```
sudo mysql_secure_installation
```
1. Quando viene richiesto, rispondi alle seguenti domande come specificato.
Per Amazon Linux:
1. **Inserisci la password corrente per root (Invio per nessuna password)**: premi `Enter` (nessuna password).
1. **Imposta la password root**: digita `Y` e premi `Enter`.
1. **Nuova password** digita una password e premi `Enter`.
1. **Immetti nuovamente la nuova password**: digita di nuovo la password e premi `Enter`. Assicurati di riporre le password in un luogo sicuro per un uso successivo.
1. **Rimuovi utenti anonimi**: digita `Y`, quindi premi `Enter`.
1. **Disattiva l'accesso root da remoto**: digita `Y`, quindi premi `Enter`.
1. **Rimuovi il database di test e accedivi**: digita `Y`, quindi premi `Enter`.
1. **Ricarica le tabelle dei privilegi**: digita `Y`, quindi premi `Enter`.
In Ubuntu Server:
1. **Configura il plug-in VALIDATE PASSWORD**: immetti `y`, quindi premi `Enter`.
1. **Configura uno dei tre livelli di policy di convalida della password**: immetti `0`, `1` o `2`, quindi premi `Enter`.
1. **Nuova password**: immetti una password e premi `Enter`.
1. **Immetti nuovamente la nuova password**: immetti di nuovo la password e premi `Enter`. Assicurati di riporre le password in un luogo sicuro per un uso successivo.
1. **Continua con la password fornita**: immetti `y`, quindi premi `Enter`.
1. **Rimuovi utenti anonimi**: immetti `y`, quindi premi `Enter`.
1. **Disattiva l'accesso root da remoto**: immetti `y`, quindi premi `Enter`.
1. **Rimuovi il database di test e l'accesso**: immetti `y`, quindi premi `Enter`.
1. **Ricarica le tabelle dei privilegi**: immetti `y`, quindi premi `Enter`.
1. Per interagire direttamente con MySQL, avvia il MySQL client da riga di comando come utente root eseguendo il comando seguente. Quando richiesto, digita la password dell'utente root impostata in precedenza, quindi premi `Enter`. Il prompt cambia a `mysql>` mentre si è in MySQL client a riga di comando.
```
sudo mysql -uroot -p
```
1. Per uscire da MySQL client da riga di comando, esegui il seguente comando. Il prompt torna a essere `$`.
```
exit;
```
## Fase 3: configurare un sito Web
In questo passaggio, si configura la cartella principale predefinita del sito Web per Apache Server HTTP con proprietari e autorizzazioni di accesso consigliati. Quindi crei un PHPpagina Web basata all'interno della cartella principale del sito Web predefinita.
Consenti quindi al traffico Web in entrata di visualizzare quella pagina Web configurando il gruppo di sicurezza in Amazon EC2 e la lista di controllo degli accessi alla rete (ACL di rete) in Amazon Virtual Private Cloud (Amazon VPC) associati a questo ambiente. EC2 Ogni EC2 ambiente deve essere associato sia a un gruppo di sicurezza in Amazon EC2 che a un ACL di rete in Amazon VPC. Tuttavia, mentre la lista di controllo degli accessi di rete predefinita in un Account AWS permette tutto il traffico in entrata e in uscita per l'ambiente, il gruppo di sicurezza predefinito permette solo il traffico in entrata utilizzando SSH sulla porta 22. Per ulteriori informazioni, consulta [Impostazioni VPC per AWS Cloud9 ambienti di sviluppo](vpc-settings.md).
Finisci questa fase con la corretta visualizzazione della pagina Web dall'esterno dell'IDE AWS Cloud9 .
1. Configura la radice predefinita del sito Web per Apache Server HTTP (`/var/www/html`) con proprietari e autorizzazioni di accesso consigliati. A tale scopo, esegui i seguenti sei comandi, uno alla volta nell'ordine seguente, in una sessione terminale nell' AWS Cloud9 IDE. Per capire cosa fa ogni comando, leggere le informazioni dopo il carattere `#` dopo ogni comando.
Per Amazon Linux:
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ec2-user # Add the user ec2-user (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a apache # Add the user apache (Apache HTTP Server) to the group web-content.
sudo chown -R ec2-user:web-content /var/www/html # Change the owner of /var/www/html and its files to user ec2-user and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
In Ubuntu Server:
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ubuntu # Add the user ubuntu (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a www-data # Add the user www-data (Apache HTTP Server) to the group web-content.
sudo chown -R ubuntu:web-content /var/www/html # Change the owner of /var/www/html and its files to user ubuntu and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
1. Crea un PHPpagina Web basata denominata `index.php` nella cartella principale del sito Web predefinita per Apache Server HTTP (ovvero`/var/www/html`) eseguendo il comando seguente.
Per Amazon Linux:
```
sudo touch /var/www/html/index.php && sudo chown -R ec2-user:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
Il comando precedente per Amazon Linux modifica anche il proprietario del file`ec2-user`, cambia il gruppo del file in e modifica le autorizzazioni del file in read/write for the user, and read/execute per il gruppo e altri. `web-content`
In Ubuntu Server:
```
sudo touch /var/www/html/index.php && sudo chown -R ubuntu:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
Il comando precedente per Ubuntu Il server modifica inoltre il proprietario del file in`ubuntu`, modifica il gruppo del file in e modifica le autorizzazioni del file in quelle relative al gruppo e read/write for the user, and read/execute ad altri. `web-content`
Se i comandi precedenti vengono eseguiti correttamente, viene creato il file `index.php` con i seguenti contenuti.
```
```
1. Abilita il traffico Web in entrata sulla porta 80 per visualizzare la nuova pagina Web configurando l'ACL di rete in Amazon VPC e il gruppo di sicurezza Amazon associato a EC2 questo ambiente. EC2 Per eseguire questa operazione, esegui uno alla volta i seguenti otto comandi nell'ordine indicato. Per capire cosa fa ogni comando, leggere le informazioni dopo il carattere `#` per ogni comando.
**Importante**
L'esecuzione dei seguenti comandi abilita il traffico Web in entrata sulla porta 80 per **tutti gli** EC2 ambienti e le EC2 istanze Amazon associati al gruppo di sicurezza e all'ACL di rete per questo ambiente. Ciò potrebbe comportare l'attivazione inaspettata del traffico Web in entrata sulla porta 80 per ambienti EC2 e EC2 istanze Amazon diversi da questa.
**Nota**
I comandi dal secondo al quarto riportati di seguito consentono al gruppo di sicurezza di permettere il traffico Web in ingresso sulla porta 80. Se hai un gruppo di sicurezza predefinito che consente solo il traffico SSH in entrata sulla porta 22, è necessario eseguire il primo comando e quindi i comandi dal secondo al quarto. Tuttavia, se è già disponibile un gruppo di sicurezza personalizzato che consente il traffico Web in ingresso sulla porta 80, è possibile ignorare l'esecuzione di tali comandi.
I comandi dal quinto all'ottavo riportati di seguito abilitano la lista di controllo degli accessi di rete a permettere il traffico Web in ingresso sulla porta 80. Se hai una lista di controllo degli accessi di rete predefinita che consente già tutto il traffico in entrata su tutte le porte, puoi saltare in sicurezza questi comandi. Tuttavia, supponi di avere una lista di controllo degli accessi di rete personalizzata che non consente il traffico Web in ingresso sulla porta 80. Esegui il primo comando, quindi i comandi dal quinto all'ottavo dei seguenti.
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Add an inbound rule to the security group to allow all incoming IPv4-based traffic over port 80.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Add an inbound rule to the security group to allow all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10000 --cidr-block 0.0.0.0/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv4-based traffic over port 80. Advanced users: change this suggested rule number as desired.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10100 --ipv6-cidr-block ::/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv6-based traffic over port 80. Advanced users: change this suggested rule number as desired.
```
1. Ottieni l'URL del file `index.php` nella root del server Web. A tale scopo, esegui il comando seguente e utilizza una nuova scheda del browser Web o un browser Web diverso dall' AWS Cloud9 IDE per accedere all'URL visualizzato. In caso di successo, la pagina Web visualizza informazioni su Apache Server HTTP, MySQL, PHPe altre impostazioni correlate.
```
MY_PUBLIC_IP=$(curl http://169.254.169.254/latest/meta-data/public-ipv4) && echo http://$MY_PUBLIC_IP/index.php # Get the URL to the index.php file within the web server root.
```
## Fase 4: pulizia
Supponi di voler continuare a utilizzare questo ambiente ma di voler disabilitare il traffico Web in entrata sulla porta 80. Esegui i seguenti otto comandi, uno alla volta nell'ordine indicato, per eliminare le corrispondenti regole di traffico in ingresso impostate in precedenza nel gruppo di sicurezza e nella lista di controllo degli accessi di rete associati all'ambiente. Per capire cosa fa ogni comando, leggere le informazioni dopo il carattere `#` per ogni comando.
**Importante**
L'esecuzione dei seguenti comandi disabilita il traffico Web in entrata sulla porta 80 per **tutti gli** EC2 ambienti e le EC2 istanze Amazon associati al gruppo di sicurezza e all'ACL di rete per questo ambiente. Ciò potrebbe comportare la disabilitazione inaspettata del traffico Web in entrata sulla porta 80 per ambienti EC2 e EC2 istanze Amazon diversi da questa.
**Nota**
I comandi dal quinto all'ottavo riportati di seguito rimuovono le regole esistenti che impediscono alla lista di controllo degli accessi di rete di consentire il traffico Web in ingresso sulla porta 80. Se hai una lista di controllo degli accessi di rete predefinita che consente già tutto il traffico in entrata su tutte le porte, puoi ignorare questi comandi. Tuttavia, supponi di avere una lista di controllo degli accessi di rete personalizzata con regole esistenti che consentono il traffico Web in ingresso sulla porta 80 e vuoi eliminare tali regole. Dovrai eseguire il primo comando e quindi i comandi dal quinto all'ottavo.
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Delete the existing inbound rule from the security group to block all incoming IPv4-based traffic over port 80.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Delete the existing inbound rule from the security group to block all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10000 # Delete the existing inbound rule from the network ACL to block all IPv4-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10100 # Delete the existing inbound rule from the network ACL to block all IPv6-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
```
Una volta terminato di usare l'ambiente, eliminalo per evitare di continuare ad addebitare i costi sul tuo Account AWS. Per istruzioni, consultare [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# WordPress tutorial per AWS Cloud9
Questo tutorial consente di installare ed eseguire l'installazione WordPress in un ambiente di AWS Cloud9 sviluppo. WordPress è un sistema di gestione dei contenuti (CMS) open source ampiamente utilizzato per la distribuzione di contenuti web.
**Nota**
Seguire questo tutorial e creare questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon Elastic Compute Cloud (Amazon EC2). Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/).
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
+ **Hai un'istanza up-to-date EC2 con tutti i pacchetti software più recenti**. Nella finestra del terminale AWS Cloud9 IDE, puoi eseguire l'esecuzione `yum update` con l'`-y`opzione per installare gli aggiornamenti senza chiedere conferma. Se desideri esaminare gli aggiornamenti prima di installarli, puoi omettere questa opzione.
```
sudo yum update -y
```
## Panoramica dell'installazione
L'installazione WordPress sull'istanza EC2 del tuo ambiente prevede i seguenti passaggi:
1. Installazione e configurazione di MariadB Server, un database relazionale open source che memorizza le informazioni per le installazioni WordPress
1. Installazione e configurazione, che include la modifica del WordPress file di configurazione `wordpress.conf`
1. Configurazione del server Apache che ospita il sito WordPress
1. Visualizzazione in anteprima del contenuto WordPress Web ospitato dal server Apache
## Fase 1: installazione e configurazione di MariaDB Server
1. Nell' AWS Cloud9 IDE, scegli **Finestra**, **Nuovo terminale** e inserisci i seguenti comandi per installare e avviare un'installazione di MariaDB Server:
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. Quindi, esegui lo script `mysql_secure_installation` per migliorare la sicurezza dell'installazione di MariaDB Server.
Quando fornisci risposte allo script, premi **Invio** per la prima domanda per mantenere vuota la password root. Premi **n** per `Set root password?`, quindi **y** per ciascuna delle altre opzioni di protezione.
```
mysql_secure_installation
```
1. Ora crea una tabella di database per memorizzare WordPress le informazioni utilizzando il client MariaDB.
(Premi **Invio** quando ti viene richiesta la password).
```
sudo mysql -u root -p
MariaDB [(none)]> create database wp_test;
MariaDB [(none)]> grant all privileges on wp_test.* to root@localhost identified by ';'
```
1. Per disconnetterti dal client MariaDB, esegui il comando `exit`.
## Fase 2: Installazione e configurazione WordPress
1. Nella finestra del terminale IDE, accedi alla directory `environment`, quindi crea le directory `config` e `wordpress`. Quindi esegui il comando `touch` per creare un file denominato `wordpress.conf` nella directory `config`:
```
cd /home/ec2-user/environment
mkdir config wordpress
touch config/wordpress.conf
```
1. Utilizzate l'editor IDE o vim per l'aggiornamento `wordpress.conf` con le informazioni di configurazione dell'host che consentano al server Apache di fornire contenuti: WordPress
```
# Ensure that Apache listens on port 80
Listen 8080
DocumentRoot "/var/www/wordpress"
ServerName www.example.org
# Other directives here
```
1. Ora esegui i seguenti comandi per recuperare il file di archivio richiesto e installarlo: WordPress
```
cd /home/ec2-user/environment
wget https://wordpress.org/latest.tar.gz
tar xvf latest.tar.gz
```
1. Esegui il comando `touch` per creare un file denominato `wp-config.php` nella directory `environment/wordpress`:
```
touch wordpress/wp-config.php
```
1. Usa l'editor IDE o vim per aggiornare `wp-config.php` e sostituire i dati di esempio con la tua configurazione:
```
// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define( 'DB_NAME', 'wp_test' );
/** MySQL database username */
define( 'DB_USER', 'wp_user' );
/** MySQL database password */
define( 'DB_PASSWORD', 'YourSecurePassword' );
/** MySQL hostname */
define( 'DB_HOST', 'localhost' );
/** Database Charset to use in creating database tables. */
define( 'DB_CHARSET', 'utf8' );
/** The Database Collate type. Don't change this if in doubt. */
define( 'DB_COLLATE', '' );
define('FORCE_SSL', true);
if ($_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https') $_SERVER['HTTPS'] = 'on';
```
## Fase 3: configurazione del server HTTP Apache
1. Nella finestra del terminale AWS Cloud9 IDE, assicuratevi di avere Apache installato:
```
httpd -v
```
Se il server Apache non è installato, esegui il comando seguente:
```
sudo yum install -y httpd
```
1. Passa alla directory `/etc/httpd/conf.d`, che è la posizione dei file di configurazione dell'host virtuale di Apache. Quindi utilizza il comando `ln` per collegare `wordpress.conf` creato precedentemente nella directory di lavoro corrente (`/etc/httpd/conf.d`):
```
cd /etc/httpd/conf.d
sudo ln -s /home/ec2-user/environment/config/wordpress.conf
```
1. Ora accedi alla directory `/var/www`, che è la cartella root di default per i server Apache. Quindi utilizza il comando `ln` per collegare la directory `wordpress` creata precedentemente nella directory di lavoro corrente (`/var/www`):
```
cd /var/www
sudo ln -s /home/ec2-user/environment/wordpress
```
1. Esegui il comando `chmod` per permettere al server Apache di eseguire il contenuto nella sottodirectory `wordpress`:
```
sudo chmod +x /home/ec2-user/
```
1. Ora riavvia il server Apache per permettergli di rilevare le nuove configurazioni:
```
sudo service httpd restart
```
## Fase 4: Visualizzazione in anteprima dei contenuti web WordPress
1. Utilizzando l' AWS Cloud9 IDE, crea un nuovo file chiamato `index.html` nella seguente directory:`environment/wordpress`.
1. Aggiungi testo in formato HTML a `index.html`. Esempio:
```
Hello World!
```
1. Nella finestra **Ambiente**, scegliete il `index.html` file, quindi scegliete **Anteprima, Anteprima** **applicazione in esecuzione**.
La pagina Web, che visualizza il messaggio *Hello World\$1*, viene visualizzata nella scheda di anteprima dell'applicazione. Per visualizzare i contenuti Web nel browser preferito, scegli **Pop Out Into a New Window** (Mostra in una nuova finestra).
Se eliminate il `index.html` file e aggiornate la scheda di anteprima dell'applicazione, viene visualizzata la pagina di WordPress configurazione.
## Gestione degli errori di contenuti misti
I browser Web visualizzano errori di contenuto misto per un WordPress sito se vengono caricati script o contenuti HTTPS e HTTP contemporaneamente. La formulazione dei messaggi di errore dipende dal browser Web che stai utilizzando, ma vieni informato che la connessione a un sito non è sicura o non è completamente sicura. Inoltre, il browser web blocca l'accesso ai contenuti misti.
**Importante**
Per impostazione predefinita, tutte le pagine Web a cui accedi nella scheda di anteprima dell'applicazione dell'IDE AWS Cloud9 utilizzano automaticamente il protocollo HTTPS. Se l'URI di una pagina è caratterizzato da un protocollo `http` non sicuro, viene sostituito automaticamente da `https`. E non è possibile accedere ai contenuti non sicuri riportando manualmente `https` a `http`.
Per indicazioni sull'implementazione di HTTPS per il tuo sito web, consulta la [WordPressdocumentazione](https://wordpress.org/support/article/https-for-wordpress/).
# Tutorial Java per AWS Cloud9
**Importante**
Se utilizzi un ambiente di AWS Cloud9 sviluppo supportato da un'istanza EC2 con 2 GiB o più di memoria, ti consigliamo di attivare il supporto Java avanzato. Ciò consente di accedere a caratteristiche di produttività come il completamento del codice, l'analisi del codice con segnalazione degli errori, le operazioni specifiche per il contesto e le opzioni di debug, come i punti di interruzione e le suddivisioni in fasi.
Per ulteriori informazioni, consulta [Supporto avanzato per lo sviluppo Java](enhanced-java.md).
Questo tutorial ti consente di eseguire del codice Java in un ambiente di AWS Cloud9 sviluppo.
L'esecuzione di questo tutorial e la creazione di questo esempio potrebbero comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-java-prerequisites)
+ [Fase 1: installare gli strumenti necessari](#sample-java-install)
+ [Fase 2: aggiungere un codice](#sample-java-code)
+ [Fase 3: costruire ed eseguire il codice](#sample-java-run)
+ [Passaggio 4: Configurazione per l'utilizzo di AWS SDK per Java](#sample-java-sdk)
+ [Fase 5: Configurare la gestione AWS delle credenziali nel proprio ambiente](#sample-java-sdk-creds)
+ [Passaggio 6: Aggiungere AWS il codice SDK](#sample-java-sdk-code)
+ [Passaggio 7: Crea ed esegui il codice AWS SDK](#sample-java-sdk-run)
+ [Fase 8: Pulizia](#sample-java-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare gli strumenti necessari
In questa fase, installate un set di strumenti di sviluppo Java nel vostro ambiente di AWS Cloud9 sviluppo. Se nell'ambiente è già installato un set di strumenti di sviluppo Java, come Oracle JDK o OpenJDK, puoi passare a [Fase 2: aggiungere un codice](#sample-java-code). Questo esempio è stato sviluppato con OpenJDK 8, che puoi installare nell'ambiente completando la procedura seguente.
1. Conferma se OpenJDK 8 è già installato. Per fare ciò, in una sessione terminale nell' AWS Cloud9 IDE, esegui la versione a riga di comando di Java runner con l'**`-version`**opzione. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale).
```
java -version
```
Dipendentemente dall'output del comando precedente, effettua una delle opzioni seguenti:
+ Se l'output indica che il comando `java` non viene trovato, continua con la fase 2 di questa procedura per installare OpenJDK 8.
+ Se l'output contiene valori che iniziano con `Java(TM)`, `Java Runtime Environment`, `Java SE`, `J2SE` o `Java2`, OpenJDK non è installato o non è impostato come set di strumenti di sviluppo Java predefinito. Continua con la fase 2 di questa procedura per installare OpenJDK 8, quindi passa all'utilizzo di OpenJDK 8.
+ Se l'output contiene valori che iniziano con `java version 1.8` e `OpenJDK`, passa a [Fase 2: aggiungere un codice](#sample-java-code). OpenJDK 8 è installato correttamente per questo esempio.
+ Se l'output contiene una `java version` inferiore a `1.8` e valori che iniziano con `OpenJDK`, continua con la fase 2 di questa procedura per aggiornare la versione di OpenJDK a OpenJDK 8.
1. Assicurati che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug i più recenti. Per effettuare questa operazione, esegui lo strumento yum (per Amazon Linux) o apt (per Ubuntu Server) con il comando ** `update` **.
Per Amazon Linux:
```
sudo yum -y update
```
Per Ubuntu Server:
```
sudo apt update
```
1. Installa OpenJDK 8. Per effettuare questa operazione, esegui lo strumento yum (per Amazon Linux) o apt (per Ubuntu Server) con il comando ** `install` **, specificando il pacchetto OpenJDK 8.
Per Amazon Linux:
```
sudo yum -y install java-1.8.0-openjdk-devel
```
Per Ubuntu Server:
```
sudo apt install -y openjdk-8-jdk
```
Per ulteriori informazioni, consulta [How to download and install prebuilt OpenJDK packages](https://openjdk.org/install/) sul sito Web di OpenJDK.
1. Passa o aggiorna il set di strumenti di sviluppo Java predefinito a OpenJDK 8. A tale scopo, eseguire il comando ** `update-alternatives` ** con l'opzione ** `--config` **. Esegui il comando due volte per passare o aggiornare le versioni della riga di comando del runner e compilatore Java.
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
A ogni prompt digita il numero di selezione per OpenJDK 8 (quello che contiene `java-1.8`).
1. Verifica che le versioni della riga di comando del runner e compilatore Java utilizzino OpenJDK 8. Per effettuare questa operazione, esegui le versioni della riga di comando del runner e compilatore Java con l'opzione `-version`.
```
java -version
javac -version
```
Se OpenJDK 8 è installato e impostato correttamente, l'output della versione del runner Java contiene un valore che inizia con `openjdk version 1.8` e l'output della versione del compilatore Java inizia con il valore `javac 1.8`.
## Fase 2: aggiungere un codice
Nell' AWS Cloud9 IDE, create un file con il codice seguente e salvate il file con il nome`hello.java`. (Per creare un file, nella barra dei menu scegli **File**, **New File** (Nuovo file). Per salvare il file, scegli **File**,**Save** (Salva)).
```
public class hello {
public static void main(String []args) {
System.out.println("Hello, World!");
System.out.println("The sum of 2 and 3 is 5.");
int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);
System.out.format("The sum of %s and %s is %s.\n",
args[0], args[1], Integer.toString(sum));
}
}
```
## Fase 3: costruire ed eseguire il codice
1. Utilizza la versione della riga di comando del compilatore Java per compilare il file `hello.java` in un file `hello.class`. Per fare ciò, utilizzando il terminale nell' AWS Cloud9 IDE, dalla stessa directory del `hello.java` file, esegui il compilatore Java, specificando il `hello.java` file.
```
javac hello.java
```
1. Utilizza la versione della riga di comando del runner Java per eseguire il file `hello.class`. Per effettuare questa operazione, dalla stessa directory del file `hello.class`, esegui il runner Java, specificando il nome della classe `hello` che è stata dichiarata nel file `hello.java`, con due numeri interi da aggiungere (ad esempio, `5` e `9`).
```
java hello 5 9
```
1. Confronta i risultati.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Passaggio 4: Configurazione per l'utilizzo di AWS SDK per Java
Puoi migliorare questo esempio per utilizzare il bucket Amazon S3, AWS SDK per Java elencare i bucket disponibili e quindi eliminare il bucket appena creato.
In questa fase si installa [Apache Maven](https://maven.apache.org/) o [Gradle](https://gradle.org/) nell'ambiente. Maven e Gradle sono sistemi di automazione di compilazione comuni che possono essere usati con progetti Java. Dopo aver installato Maven o Gradle, è possibile usarlo per generare un nuovo progetto Java. In questo nuovo progetto, aggiungi un riferimento ad AWS SDK per Java. Ciò AWS SDK per Java fornisce un modo conveniente per interagire con AWS servizi come Amazon S3, dal tuo codice Java.
**Topics**
+ [Configurazione con Maven](#sample-java-sdk-maven)
+ [Configurazione con Gradle](#sample-java-sdk-gradle)
### Configurazione con Maven
1. Installa Maven nell'ambiente. Per vedere se Maven è già installato, usando il terminale nell' AWS Cloud9 IDE, esegui Maven con l'opzione. **`-version`**
```
mvn -version
```
In caso di esito positivo, l'output includerà il numero di versione di Maven. Se Maven è già installato, passa alla fase 4 in questa procedura per utilizzare Maven per generare un nuovo progetto Java nell'ambiente.
1. Installa Maven utilizzando il terminale per eseguire i seguenti comandi.
Per Amazon Linux, i seguenti comandi ottengono informazioni sul repository di pacchetti in cui è archiviato Maven, quindi utilizzano queste informazioni per installare Maven.
```
sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo
sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
sudo yum install -y apache-maven
```
Per ulteriori informazioni sui comandi precedenti, consulta [Extra Packages for Enterprise Linux (EPEL)](https://docs.fedoraproject.org/en-US/epel/) sul sito Web Fedora Project Wiki.
Per Ubuntu Server, esegui invece il comando seguente.
```
sudo apt install -y maven
```
1. Conferma l'installazione eseguendo Maven con l'opzione ** `-version` **.
```
mvn -version
```
1. Utilizza Maven per generare un nuovo progetto Java. Per effettuare questa operazione, utilizza il terminale per eseguire il comando seguente dalla directory in cui Maven deve generare il progetto (ad esempio, la directory principale dell'ambiente).
```
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
Il comando precedente crea la seguente struttura di directory per il progetto nell'ambiente.
```
my-app
|- src
| `- main
| `- java
| `- com
| `- mycompany
| `- app
| `-App.java
|- test
| `- java
| `- com
| `- mycompany
| `- app
| `- AppTest.java
`- pom.xml
```
Per ulteriori informazioni sulla struttura di directory precedente, consulta [Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) e [Introduction to the Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) sul sito Web Apache Maven Project.
1. Modifica il file Project Object Model (POM) per il progetto. Un file POM definisce le impostazioni di un progetto Maven. Per effettuare questa operazione, dalla finestra **Environment (Ambiente)** apri il file `my-app/pom.xml`. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `pom.xml`.
```
4.0.0
com.mycompany.app
my-app
jar
1.0-SNAPSHOT
org.apache.maven.plugins
maven-assembly-plugin
3.6.0
jar-with-dependencies
com.mycompany.app.App
package
single
junit
junit
3.8.1
test
com.amazonaws
aws-java-sdk
1.11.330
```
Il file POM precedente include le impostazioni di progetto che specificano dichiarazioni come le seguenti:
+ L'impostazione `artifactid` di `my-app` imposta il nome della directory principale del progetto, mentre l'impostazione `group-id` di `com.mycompany.app` imposta la struttura di sottodirectory `com/mycompany/app` e la dichiarazione `package` nei file `App.Java` e `AppTest.java`.
+ L'impostazione `artifactId` di `my-app`, con l'impostazione `packaging` di `jar`, l'impostazione `version` di `1.0-SNAPSHOT` e l'impostazione `descriptorRef` di `jar-with-dependencies` impostano il nome del file JAR di output di `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar`.
+ La sezione `plugin` dichiara che verrà creato un singolo JAR, che include tutte le dipendenze.
+ La `dependency` sezione con l'`groupId`impostazione `com.amazon.aws` e l'impostazione di `aws-java-sdk` include i `artifactId` file della libreria. AWS SDK per Java La versione dell' AWS SDK per Java da utilizzare è indicata nell'impostazione `version`. Per usare una versione diversa, sostituire questo numero di versione.
Passare direttamente a [Fase 5: Configurare la gestione AWS delle credenziali nel proprio ambiente](#sample-java-sdk-creds).
### Configurazione con Gradle
1. Installa Gradle nell'ambiente. Per vedere se Gradle è già installato, usando il terminale nell' AWS Cloud9 IDE, esegui Gradle con l'**`-version`**opzione.
```
gradle -version
```
In caso di esito positivo, l'output includerà il numero di versione di Gradle. Se Gradle è già installato, passa alla fase 4 in questa procedura per utilizzare Gradle per generare un nuovo progetto Java nell'ambiente.
1. Installa Gradle utilizzando il terminale per eseguire i seguenti comandi. Questi comandi consentono di installare ed eseguire lo strumento SDKMAN\$1 e di utilizzare quindi SDKMAN\$1 per installare la versione più recente di Gradle.
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
Per ulteriori informazioni sui comandi precedenti, consulta [Installation](https://sdkman.io/install) sul sito Web SDKMAN\$1 e [Install with a package manager](https://gradle.org/install/#with-a-package-manager) sul sito Web Gradle.
1. Conferma l'installazione eseguendo Gradle con l'opzione ** `-version` **.
```
gradle -version
```
1. Usa Gradle per generare un nuovo progetto Java nell'ambiente. Per effettuare questa operazione, usa il terminale per eseguire i seguenti comandi per creare una directory per il progetto, quindi passa a quella directory.
```
mkdir my-app
cd my-app
```
1. Esegui il comando seguente per fare in modo che Gradle generi un nuovo progetto di applicazione Java nella directory `my-app` dell'ambiente.
```
gradle init --type java-application
```
Il comando precedente crea la seguente struttura di directory per il progetto nell'ambiente.
```
my-app
|- .gradle
| `- (various supporting project folders and files)
|- gradle
| `- (various supporting project folders and files)
|- src
| |- main
| | `- java
| | `- App.java
| `- test
| `- java
| `- AppTest.java
|- build.gradle
|- gradlew
|- gradlew.bat
`- settings.gradle
```
1. Modifica `AppTest.java` per il progetto. Se non si effettua questa operazione, il progetto potrebbe non essere creato o eseguito come previsto. Per effettuare questa operazione, dalla finestra **Environment (Ambiente)** apri il file `my-app/src/test/java/AppTest.java`. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `AppTest.java`.
```
import org.junit.Test;
import static org.junit.Assert.*;
public class AppTest {
@Test public void testAppExists () {
try {
Class.forName("com.mycompany.app.App");
} catch (ClassNotFoundException e) {
fail("Should have a class named App.");
}
}
}
```
1. Modifica il file `build.gradle` per il progetto. Un file `build.gradle` definisce le impostazioni di un progetto Gradle. Per effettuare questa operazione, dalla finestra **Environment (Ambiente)** apri il file `my-app/build.gradle`. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `build.gradle`.
```
apply plugin: 'java'
apply plugin: 'application'
repositories {
jcenter()
mavenCentral()
}
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
}
}
apply plugin: "io.spring.dependency-management"
dependencyManagement {
imports {
mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330'
}
}
dependencies {
compile 'com.amazonaws:aws-java-sdk-s3'
testCompile group: 'junit', name: 'junit', version: '4.12'
}
run {
if (project.hasProperty("appArgs")) {
args Eval.me(appArgs)
}
}
mainClassName = 'App'
```
Il file `build.gradle` precedente include le impostazioni di progetto che specificano dichiarazioni come le seguenti:
+ Il `io.spring.dependency-management` plugin viene utilizzato per importare la AWS SDK per Java Maven Bill of Materials (BOM) per gestire le AWS SDK per Java dipendenze del progetto. `classpath`dichiara la versione da usare. Per usare una versione diversa, sostituire questo numero di versione.
+ `com.amazonaws:aws-java-sdk-s3` include la porzione di Amazon S3 dei file libreria dell' AWS SDK per Java . `mavenBom` indica la versione da utilizzare. Per usare una versione diversa, sostituire questo numero di versione.
## Fase 5: Configurare la gestione AWS delle credenziali nel proprio ambiente
Ogni volta che si utilizza il AWS SDK per Java per chiamare un AWS servizio, è necessario fornire un set di AWS credenziali con la chiamata. Queste credenziali determinano se AWS SDK per Java dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.
In questa fase si archiviano le credenziali all'interno dell'ambiente A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento.
Per ulteriori informazioni, consulta [Configurazione delle credenziali e della regione AWS per lo sviluppo](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) nella *Guida per gli sviluppatori di AWS SDK per Java *.
## Passaggio 6: Aggiungere AWS il codice SDK
In questa fase si aggiungi codice per interagire con Amazon S3 e creare un bucket, elencare i bucket disponibili ed eliminare il bucket appena creato.
Dalla finestra **Environment (Ambiente)** aprire il file `my-app/src/main/java/com/mycompany/app/App.java` per Maven o il file `my-app/src/main/java/App.java` per Gradle. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `App.java`.
```
package com.mycompany.app;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import java.util.List;
public class App {
private static AmazonS3 s3;
public static void main(String[] args) {
if (args.length < 2) {
System.out.format("Usage: \n" +
"Example: my-test-bucket us-east-2\n");
return;
}
String bucket_name = args[0];
String region = args[1];
s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(region)
.build();
// List current buckets.
ListMyBuckets();
// Create the bucket.
if (s3.doesBucketExistV2(bucket_name)) {
System.out.format("\nCannot create the bucket. \n" +
"A bucket named '%s' already exists.", bucket_name);
return;
} else {
try {
System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name);
s3.createBucket(new CreateBucketRequest(bucket_name, region));
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
}
// Confirm that the bucket was created.
ListMyBuckets();
// Delete the bucket.
try {
System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name);
s3.deleteBucket(bucket_name);
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
// Confirm that the bucket was deleted.
ListMyBuckets();
}
private static void ListMyBuckets() {
List buckets = s3.listBuckets();
System.out.println("My buckets now are:");
for (Bucket b : buckets) {
System.out.println(b.getName());
}
}
}
```
## Passaggio 7: Crea ed esegui il codice AWS SDK
Per eseguire il codice della fase precedente, esegui i seguenti comandi dal terminale. Questi comandi utilizzano Maven o Gradle per creare un file JAR eseguibile per il progetto e quindi utilizzano il runner Java per eseguire il JAR. Il JAR viene eseguito con il nome del bucket da creare in Amazon S3 (ad esempio`my-test-bucket`) e l'ID della regione in cui creare AWS il bucket come input (ad esempio,). `us-east-2`
Per Maven, esegui i comandi riportati di seguito.
```
cd my-app
mvn package
java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2
```
Per Gradle, esegui i comandi riportati di seguito.
```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```
Confronta i tuoi risultati con il seguente output.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Fase 8: Pulizia
Per evitare addebiti continui sul tuo AWS account dopo aver utilizzato questo esempio, devi eliminare l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# Tutorial C\$1\$1 per AWS Cloud9
Questo tutorial consente di eseguire codice C\$1\$1 in un ambiente di AWS Cloud9 sviluppo. Il codice utilizza anche risorse fornite da [AWS SDK per C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/welcome.html), una libreria open source modularizzata multipiattaforma che puoi usare per connetterti ad Amazon Web Services.
Seguire questo tutorial e creare questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-cplusplus-prereqs)
+ [Fase 1: installare g\$1\$1 e i pacchetti di sviluppo richiesti](#sample-cplusplus-install)
+ [Passaggio 2: installazione CMake](#install-cmake)
+ [Fase 3: ottenere e costruire SDK per C\$1\$1](#install-cmake)
+ [Passaggio 4: Creare file C\$1\$1 e Lists CMake](#sample-cplusplus-sdk-code)
+ [Fase 5: costruire ed eseguire il codice C\$1\$1](#build-and-run-cpp)
+ [Fase 6: pulizia](#sample-cplusplus-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare g\$1\$1 e i pacchetti di sviluppo richiesti
Per costruire ed eseguire un'applicazione C \$1\$1, è necessaria un'utilità come `g++`, che è un compilatore C \$1\$1 fornito da [GNU Complier Collection (GCC)](https://gcc.gnu.org/).
Devi inoltre aggiungere i file di intestazione (pacchetti `-dev`) per `libcurl`, `libopenssl`, `libuuid`, `zlib` e, facoltativamente, `libpulse`per il supporto di Amazon Polly.
Il processo di installazione degli strumenti di sviluppo varia leggermente a seconda che tu stia utilizzando un'istanza Amazon Linux/Amazon Linux 2 o un'istanza Ubuntu.
------
#### [ Amazon Linux-based systems ]
Puoi verificare se l'hai già `gcc` installato eseguendo il seguente comando nel AWS Cloud9 terminale:
```
g++ --version
```
Se `g++` non è installato, puoi farlo facilmente con parte del gruppo di pacchetti chiamato "Strumenti di sviluppo". Questi strumenti vengono aggiunti a un'istanza con il comando `yum groupinstall`:
```
sudo yum groupinstall "Development Tools"
```
Esegui `g++ --version` ancora una volta per confermare che il compilatore è installato.
Ora installa i pacchetti per le librerie richieste usando il programma di gestione dei pacchetti del sistema:
```
sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
```
------
#### [ Ubuntu-based systems ]
Puoi verificare se l'hai già `gcc` installato eseguendo il seguente comando nel AWS Cloud9 terminale:
```
g++ --version
```
Se gcc non è installato, puoi farlo su un sistema basato su Ubuntu. eseguendo i seguenti comandi:
```
sudo apt update
sudo apt install build-essential
sudo apt-get install manpages-dev
```
Esegui `g++ --version` ancora una volta per confermare che il compilatore è installato.
Ora installa i pacchetti per le librerie richieste usando il programma di gestione dei pacchetti del sistema:
```
sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
```
------
## Passaggio 2: installazione CMake
Devi installare lo strumento `cmake`, che automatizza il processo di costruzione di file eseguibili dal codice sorgente.
1. Nella finestra del terminale IDE, esegui il comando seguente per ottenere l'archivio richiesto:
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
1. Estrai i file dall'archivio e accedi alla directory che contiene i file decompressi:
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
1. Quindi, esegui uno script di bootstrap e installa `cmake` eseguendo i comandi seguenti:
```
./bootstrap
make
sudo make install
```
1. Conferma di aver installato lo strumento eseguendo il comando seguente:
```
cmake --version
```
## Fase 3: ottenere e costruire SDK per C\$1\$1
Per configurare l' AWS SDK per C\$1\$1, puoi creare l'SDK direttamente dal codice sorgente o scaricare le librerie utilizzando un gestore di pacchetti. Puoi trovare dettagli sulle opzioni disponibili in [Guida introduttiva all'uso dell' AWS SDK for](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html) C\$1\$1 *AWS SDK per C\$1\$1 nella* Guida per gli sviluppatori.
Questo esempio illustra l'utilizzo di `git` per clonare il codice sorgente SDK e `cmake` per costruire l'SDK per C\$1\$1.
1. Clona il repository remoto e ottieni tutti i sottomoduli git in modo ricorsivo per l'ambiente AWS Cloud9 eseguendo i comandi seguenti nel terminale:
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. Passa alla nuova `aws-sdk-cpp` directory, crea una sottodirectory in cui creare l' AWS SDK for C\$1\$1, quindi vai a quella:
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**Nota**
Per risparmiare tempo, in questa fase si costruisce solo la sezione Amazon S3 di AWS SDK per C\$1\$1. Se desideri costruire l'SDK completo, ometti `-DBUILD_ONLY=s3` dal comando `cmake`.
Il completamento dell'SDK per C\$1\$1 può richiedere più di un'ora, in base alle risorse di calcolo disponibili per l'istanza Amazon EC2 o i server.
Utilizza `cmake` per costruire la sezione Amazon S3 dell'SDK per C\$1\$1 nella directory `sdk_build` eseguendo il comando seguente:
```
cmake .. -DBUILD_ONLY=s3
```
1. Esegui il comando `make install` in modo l'SDK costruito sia accessibile:
```
sudo make install
cd ..
```
## Passaggio 4: Creare file C\$1\$1 e Lists CMake
In questa fase si crea un file `C++` che permette agli utenti del progetto di interagire con i bucket Amazon S3.
Puoi anche creare un file `CMakeLists.txt` che fornisce istruzioni utilizzate da `cmake` per costruire la libreria C\$1\$1.
1. Nell' AWS Cloud9 IDE, create un file con questo contenuto e salvate il file con il nome `s3-demo.cpp` nella radice (`/`) del vostro ambiente.
```
#include
#include
#include
#include
#include
#include
#include
// Look for a bucket among all currently available Amazon S3 buckets.
bool FindTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
Aws::S3::Model::ListBucketsOutcome outcome = s3Client.ListBuckets();
if (outcome.IsSuccess()) {
std::cout << "Looking for a bucket named '" << bucketName << "'..."
<< std::endl << std::endl;
Aws::Vector bucket_list =
outcome.GetResult().GetBuckets();
for (Aws::S3::Model::Bucket const &bucket: bucket_list) {
if (bucket.GetName() == bucketName) {
std::cout << "Found the bucket." << std::endl << std::endl;
return true;
}
}
std::cout << "Could not find the bucket." << std::endl << std::endl;
} else {
std::cerr << "listBuckets error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Create an Amazon S3 bucket.
bool CreateTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName,
const Aws::String ®ion) {
std::cout << "Creating a bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::CreateBucketRequest request;
request.SetBucket(bucketName);
if (region != "us-east-1") {
Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
createBucketConfig.SetLocationConstraint(
Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
region));
request.SetCreateBucketConfiguration(createBucketConfig);
}
Aws::S3::Model::CreateBucketOutcome outcome =
s3Client.CreateBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket created." << std::endl << std::endl;
} else {
std::cerr << "createBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Delete an existing Amazon S3 bucket.
bool DeleteTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
std::cout << "Deleting the bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::DeleteBucketRequest request;
request.SetBucket(bucketName);
Aws::S3::Model::DeleteBucketOutcome outcome =
s3Client.DeleteBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket deleted." << std::endl << std::endl;
} else {
std::cerr << "deleteBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
#ifndef EXCLUDE_MAIN_FUNCTION
// Create an S3 bucket and then delete it.
// Before and after creating the bucket, and again after deleting the bucket,
// try to determine whether that bucket still exists.
int main(int argc, char *argv[]) {
if (argc < 3) {
std::cout << "Usage: s3-demo " << std::endl
<< "Example: s3-demo my-bucket us-east-1" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
Aws::String bucketName = argv[1];
Aws::String region = argv[2];
Aws::Client::ClientConfiguration config;
config.region = region;
Aws::S3::S3Client s3Client(config);
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!CreateTheBucket(s3Client, bucketName, region)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!DeleteTheBucket(s3Client, bucketName)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
}
Aws::ShutdownAPI(options);
return 0;
}
#endif // EXCLUDE_MAIN_FUNCTION
```
1. Crea un secondo file con questo contenuto e salvalo con il nome `CMakeLists.txt` nella radice (`/`) dell'ambiente. Questo file ti consente di compilare il tuo codice in un file eseguibile.
```
# A minimal CMakeLists.txt file for the AWS SDK for C++.
# The minimum version of CMake that will work.
cmake_minimum_required(VERSION 2.8)
# The project name.
project(s3-demo)
# Locate the AWS SDK for C++ package.
set(AWSSDK_ROOT_DIR, "/usr/local/")
set(BUILD_SHARED_LIBS ON)
find_package(AWSSDK REQUIRED COMPONENTS s3)
# The executable name and its source files.
add_executable(s3-demo s3-demo.cpp)
# The libraries used by your executable.
target_link_libraries(s3-demo ${AWSSDK_LINK_LIBRARIES})
```
## Fase 5: costruire ed eseguire il codice C\$1\$1
1. Nella directory principale dell'ambiente in cui hai salvato `s3-demo.cpp` e `CMakeLists.txt`, esegui `cmake` per costruire il progetto:
```
cmake .
make
```
1. Ora puoi eseguire il programma dalla riga di comando. Nel comando seguente, sostituisci `my-unique-bucket-name` con un nome univoco per il bucket Amazon S3 e, se necessario, sostituisci `us-east-1` con l'identificatore di un'altre regione AWS in cui desideri creare un bucket.
```
./s3-demo my-unique-bucket-name us-east-1
```
Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
Creating a bucket named 'my-unique-bucket-name'...
Bucket created.
Looking for a bucket named 'my-unique-bucket-name'...
Found the bucket.
Deleting the bucket named 'my-unique-bucket-name'...
Bucket deleted.
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
```
## Fase 6: pulizia
Per evitare addebiti continui AWS sul tuo account dopo aver finito con questo esempio, elimina l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# Tutorial in Python per AWS Cloud9
Questo tutorial mostra come eseguire codice Python in un ambiente di AWS Cloud9 sviluppo.
Seguire questo tutorial potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon Elastic Compute Cloud (Amazon EC2) e Amazon Simple Storage Service (Amazon S3). Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-python-prereqs)
+ [Fase 1: installare Python](#sample-python-install)
+ [Fase 2: aggiungere un codice](#sample-python-code)
+ [Fase 3: eseguire il codice](#sample-python-run)
+ [Fase 4: Installare e configurare AWS SDK per Python (Boto3)](#sample-python-sdk)
+ [Passaggio 5: Aggiungere il codice AWS SDK](#sample-python-sdk-code)
+ [Passaggio 6: Esegui il codice AWS SDK](#sample-python-sdk-run)
+ [Fase 7: pulire](#sample-python-clean-up)
## Prerequisiti
Prima di usare questo tutorial, assicurati di soddisfare i seguenti requisiti.
+ **Hai un ambiente di sviluppo AWS Cloud9 EC2**
Nel tutorial si presume che tu disponga di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Per informazioni dettagliate, vedi [Creare un ambiente EC2](create-environment-main.md).
Se disponi di un tipo diverso di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo tutorial.
+ **Hai aperto l' AWS Cloud9 IDE per quell'ambiente**
Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per informazioni dettagliate, vedi [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare Python
1. In una sessione terminale nell' AWS Cloud9 IDE, conferma se Python è già installato eseguendo il **`python --version`**comando. Per avviare una nuova sessione del terminale, dalla barra dei menu seleziona **Window (Finestra)**, **New Terminal (Nuovo terminale)**. Se Python è installato, passa alla [Fase 2: aggiungere un codice](#sample-python-code).
1. Esegui il comando ** `yum update`** (per Amazon Linux) o **`apt update`** (per Ubuntu Server) per verificare che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug più recenti.
Per Amazon Linux:
```
sudo yum -y update
```
Per Ubuntu Server:
```
sudo apt update
```
1. Installa Python eseguendo il comando ** `install` **.
Per Amazon Linux:
```
sudo yum -y install python3
```
Per Ubuntu Server:
```
sudo apt-get install python3
```
## Fase 2: aggiungere un codice
Nell' AWS Cloud9 IDE, create un file con il seguente contenuto e salvate il file con il nome`hello.py`. (Per creare un file, nella barra dei menu scegli **File**, **New File** (Nuovo file). Per salvare il file, scegli **File**, **Save** (Salva)).
```
import sys
print('Hello, World!')
print('The sum of 2 and 3 is 5.')
sum = int(sys.argv[1]) + int(sys.argv[2])
print('The sum of {0} and {1} is {2}.'.format(sys.argv[1], sys.argv[2], sum))
```
## Fase 3: eseguire il codice
1. Nell' AWS Cloud9 IDE, nella barra dei menu scegli **Esegui, Esegui** **configurazioni**, **Nuova configurazione di esecuzione**.
1. Nella scheda **[New] - Stopped ([Nuovo] - Arrestato)** digitare `hello.py 5 9` per **Command**. Nel codice, `5` rappresenta `sys.argv[1]` e `9` rappresenta `sys.argv[2]`.
1. Seleziona **Run (Esegui)** ed esegui un confronto dell'output.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
1. Per impostazione predefinita, seleziona AWS Cloud9 automaticamente un runner per il codice. Per modificare lo strumento di esecuzione, scegliere **Runner (Strumento di esecuzione)**, quindi scegliere **Python 2** o **Python 3**.
**Nota**
È possibile creare strumenti di esecuzione personalizzati per versioni specifiche di Python. Per informazioni dettagliate, vedi [Creazione di un builder o un'esecuzione](build-run-debug.md#build-run-debug-create-builder-runner).
## Fase 4: Installare e configurare AWS SDK per Python (Boto3)
Ti AWS SDK per Python (Boto3) consente di utilizzare il codice Python per interagire con AWS servizi come Amazon S3. Ad esempio, puoi utilizzare l'SDK per creare un bucket Amazon S3, elencare i bucket disponibili ed eliminare il bucket appena creato.
### Installazione pip.
Nell' AWS Cloud9 IDE, verifica se `pip` è già installato per la versione attiva di Python eseguendo il **`python -m pip --version`**comando. Se `pip` è installato, passare alla sezione successiva.
Esegui i comandi seguenti per installare `pip`. Poiché sudo si trova in un ambiente diverso da quello dell'utente, è necessario specificare la versione di Python da utilizzare se differisce dalla versione con alias corrente.
```
curl -O https://bootstrap.pypa.io/get-pip.py # Get the install script.
sudo python3 get-pip.py # Install pip for Python 3.
python -m pip --version # Verify pip is installed.
rm get-pip.py # Delete the install script.
```
Per ulteriori informazioni, vedere [Installazione](https://pip.pypa.io/en/stable/installing/) sul sito Web `pip`.
### Installa il AWS SDK per Python (Boto3)
Dopo l'installazione`pip`, installala AWS SDK per Python (Boto3) eseguendo il **`pip install`**comando.
```
sudo python3 -m pip install boto3 # Install boto3 for Python 3.
python -m pip show boto3 # Verify boto3 is installed for the current version of Python.
```
Per ulteriori informazioni, consulta la sezione "Installazione" di [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) in AWS SDK per Python (Boto3).
### Configurazione delle credenziali nell'ambiente
Ogni volta che si utilizza il AWS SDK per Python (Boto3) per chiamare un AWS servizio, è necessario fornire un set di credenziali con la chiamata. Queste credenziali determinano se l'SDK dispone delle autorizzazioni necessarie per effettuare la chiamata. Se le credenziali non coprono le autorizzazioni necessarie, la chiamata non riesce.
Per archiviare le credenziali nell'ambiente, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md) e torna a questo argomento.
Per ulteriori informazioni, consulta [Credenziali](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html) in AWS SDK per Python (Boto3).
## Passaggio 5: Aggiungere il codice AWS SDK
Aggiungi del codice utilizzato da Amazon S3 per creare un bucket, elencare i bucket disponibili e, facoltativamente, eliminare il bucket appena creato.
Nell' AWS Cloud9 IDE, create un file con il seguente contenuto e salvate il file con il nome`s3.py`.
```
import sys
import boto3
from botocore.exceptions import ClientError
def list_my_buckets(s3_resource):
print("Buckets:\n\t", *[b.name for b in s3_resource.buckets.all()], sep="\n\t")
def create_and_delete_my_bucket(s3_resource, bucket_name, keep_bucket):
list_my_buckets(s3_resource)
try:
print("\nCreating new bucket:", bucket_name)
bucket = s3_resource.create_bucket(
Bucket=bucket_name,
CreateBucketConfiguration={
"LocationConstraint": s3_resource.meta.client.meta.region_name
},
)
except ClientError as e:
print(
f"Couldn't create a bucket for the demo. Here's why: "
f"{e.response['Error']['Message']}"
)
raise
bucket.wait_until_exists()
list_my_buckets(s3_resource)
if not keep_bucket:
print("\nDeleting bucket:", bucket.name)
bucket.delete()
bucket.wait_until_not_exists()
list_my_buckets(s3_resource)
else:
print("\nKeeping bucket:", bucket.name)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("bucket_name", help="The name of the bucket to create.")
parser.add_argument("region", help="The region in which to create your bucket.")
parser.add_argument(
"--keep_bucket",
help="Keeps the created bucket. When not "
"specified, the bucket is deleted "
"at the end of the demo.",
action="store_true",
)
args = parser.parse_args()
s3_resource = (
boto3.resource("s3", region_name=args.region)
if args.region
else boto3.resource("s3")
)
try:
create_and_delete_my_bucket(s3_resource, args.bucket_name, args.keep_bucket)
except ClientError:
print("Exiting the demo.")
if __name__ == "__main__":
main()
```
## Passaggio 6: Esegui il codice AWS SDK
1. Nella barra dei menu, selezionare **Run (Esegui)**, **Run Configurations (Configurazioni esecuzione)**, **New Run Configuration (Nuova configurazione esecuzione)**.
1. Per **Comando**, inserisci`s3.py my-test-bucket us-west-2`, `my-test-bucket` dov'è il nome del bucket da creare e l'ID della AWS regione in cui `us-west-2` è stato creato il bucket. Per impostazione predefinita, il bucket viene eliminato prima della chiusura dello script. Per mantenere il bucket, aggiungi `--keep_bucket` al comando. Per un elenco delle AWS regioni IDs, consulta [Amazon Simple Storage Service Endpoints and Quotas](https://docs.aws.amazon.com/general/latest/gr/s3.html) nel. *Riferimenti generali di AWS*
**Nota**
I nomi dei bucket Amazon S3 devono essere univoci per tutti gli account, AWS non solo per il tuo account. AWS
1. Seleziona **Run (Esegui)** ed esegui un confronto dell'output.
```
Buckets:
a-pre-existing-bucket
Creating new bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
my-test-bucket
Deleting bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
```
## Fase 7: pulire
Per evitare addebiti continui sul tuo AWS account dopo aver terminato questo tutorial, elimina l'ambiente. AWS Cloud9 Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# Tutorial.NET per AWS Cloud9
Questo tutorial consente di eseguire del codice.NET in un ambiente di AWS Cloud9 sviluppo.
L'esecuzione di questo tutorial e la creazione di questo esempio potrebbero comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-dotnetcore-prereqs)
+ [Fase 1: installare gli strumenti necessari](#sample-dotnetcore-setup)
+ [Fase 2 (facoltativo): installare l'estensione CLI .NET per le funzioni Lambda](#sample-dotnetcore-lambda)
+ [Passaggio 3: Creare un progetto di applicazione console.NET](#sample-dotnetcore-app)
+ [Fase 4: aggiungere un codice](#sample-dotnetcore-code)
+ [Fase 5: costruire ed eseguire il codice](#sample-dotnetcore-run)
+ [Passaggio 6: Creare e configurare un progetto di applicazione console.NET che utilizzi il AWS SDK per .NET](#sample-dotnetcore-sdk)
+ [Passaggio 7: Aggiungere AWS il codice SDK](#sample-dotnetcore-sdk-code)
+ [Passaggio 8: Compila ed esegui il AWS codice SDK](#sample-dotnetcore-sdk-run)
+ [Fase 9: Pulizia](#sample-dotnetcore-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare gli strumenti necessari
In questo passaggio, installi il.NET SDK nel tuo ambiente, necessario per eseguire questo esempio.
1. Verifica se la versione più recente di.NET SDK è già installata nel tuo ambiente. A tale scopo, in una sessione terminale nell' AWS Cloud9 IDE, esegui l'interfaccia a riga di comando (CLI) .NET Core con l'**`--version`**opzione.
```
dotnet --version
```
Se la versione degli strumenti a riga di comando .NET è visualizzata ed è la versione 2.0 o superiore, passa alla[Passaggio 3: Creare un progetto di applicazione console.NET](#sample-dotnetcore-app). Se la versione è precedente alla 2.0 o se `bash: dotnet: command not found` viene visualizzato un errore del genere, continua con l'installazione di.NET SDK.
1. Per Amazon Linux, in una sessione terminale nell' AWS Cloud9 IDE, esegui i seguenti comandi per garantire l'installazione degli ultimi aggiornamenti di sicurezza e correzioni di bug e per installare un `libunwind` pacchetto necessario all'SDK.NET. Per avviare una nuova sessione del terminale, dalla barra dei menu seleziona **Window (Finestra), New Terminal (Nuovo terminale)**.
```
sudo yum -y update
sudo yum -y install libunwind
```
Per Ubuntu Server, in una sessione di terminale nell' AWS Cloud9 IDE, esegui il comando seguente per garantire l'installazione degli ultimi aggiornamenti di sicurezza e correzioni di bug. Per avviare una nuova sessione del terminale, dalla barra dei menu seleziona **Window (Finestra), New Terminal (Nuovo terminale)**.
```
sudo apt -y update
```
1. Scarica lo script di installazione.NET SDK nel tuo ambiente eseguendo il comando seguente.
```
wget https://dot.net/v1/dotnet-install.sh
```
1. Rendi lo script del programma di installazione eseguibile dall'utente corrente mediante il comando seguente.
```
sudo chmod u=rx dotnet-install.sh
```
1. Esegui lo script di installazione, che scarica e installa il.NET SDK, eseguendo il comando seguente.
```
./dotnet-install.sh -c Current
```
1. Aggiungi il.NET SDK al tuo. `PATH` A questo proposito, nel profilo della shell per l'ambiente (ad esempio, il file `.bashrc`), aggiungi la sottodirectory `$HOME/.dotnet` alla variabile `PATH` per l'ambiente, come descritto di seguito.
1. Apri il file `.bashrc` per la modifica utilizzando il comando ** `vi` **.
```
vi ~/.bashrc
```
1. Per Amazon Linux, l'utilizzo del tasto freccia Giù o `j` consente di spostarsi sulla riga che inizia con `export PATH`.
Per Ubuntu Server, è possibile spostarsi sull'ultima riga del file digitando `G`.
1. Utilizzando il tasto freccia Destra o `$`, spostati al termine di quella riga.
1. Passa alla modalità di inserimento premendo il tasto `i` (`-- INSERT ---` apparirà in fondo allo schermo).
1. Per Amazon Linux, aggiungi la sottodirectory `$HOME/.dotnet` alla variabile ** `PATH` ** digitando `:$HOME/.dotnet`. Assicurati di includere il carattere di due punti (`:`). La riga dovrebbe essere ora simile alla seguente.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
Per Ubuntu Server, premi il tasto freccia Destra, quindi `Enter` due volte e digita la riga seguente alla fine del file.
```
export PATH=$HOME/.dotnet:$PATH
```
1. Salvare il file. Per eseguire questa operazione, premi il tasto `Esc` (`-- INSERT ---` scomparirà dalla parte bassa dello schermo), scrivi `:wq` (per scrivere e quindi uscire dal file), quindi premi `Enter`.
1. Carica il.NET SDK ricercando il file. `.bashrc`
```
. ~/.bashrc
```
1. Verifica che .NET SDK sia caricato eseguendo.NET CLI con **`--help`**l'opzione.
```
dotnet --help
```
In caso di successo, viene visualizzato il numero di versione di .NET SDK, con informazioni aggiuntive sull'utilizzo.
1. Se non desideri più mantenere lo script di installazione.NET SDK nel tuo ambiente, puoi eliminarlo come segue.
```
rm dotnet-install.sh
```
## Fase 2 (facoltativo): installare l'estensione CLI .NET per le funzioni Lambda
Sebbene non sia necessario per questo tutorial, è possibile distribuire AWS Lambda funzioni e AWS Serverless Application Model applicazioni utilizzando la CLI.NET se si installa anche il pacchetto`Amazon.Lambda.Tools`.
1. Per installare il pacchetto, esegui il comando seguente:
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Ora imposta la variabile di ambiente `PATH` e `DOTNET_ROOT` in modo che punti allo strumento Lambda installato. Nel file `.bashrc` individua la sezione `export PATH` e modificala in modo che appaia simile a quanto segue (vedi Fase 1 per i dettagli sulla modifica di questo file):
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```
## Passaggio 3: Creare un progetto di applicazione console.NET
In questo passaggio, si utilizza.NET per creare un progetto denominato`hello`. Questo progetto contiene tutti i file di cui necessita.NET per eseguire una semplice applicazione dal terminale nell'IDE. Il codice dell'applicazione è scritto in C\$1.
Crea un progetto di applicazione console.NET. A tale scopo, esegui la CLI.NET con il **`new`**comando, specificando il tipo di modello di progetto dell'applicazione console e il linguaggio di programmazione da utilizzare (in questo esempio, C\$1).
L'opzione `-n` indica che il progetto viene emesso in una nuova directory, `hello`. Passiamo quindi a tale directory.
```
dotnet new console -lang C# -n hello
cd hello
```
Il comando precedente aggiunge una sottodirectory denominata `obj` con vari file e alcuni file autonomi aggiuntivi alla directory `hello`. Devi prendere nota dei seguenti due file di chiave:
+ Il file `hello/hello.csproj` contiene informazioni sul progetto di applicazione della console.
+ Il file `hello/Program.cs` contiene il codice dell'applicazione da eseguire.
## Fase 4: aggiungere un codice
In questa fase, aggiungi del codice all'applicazione.
Dalla finestra **Ambiente dell'** AWS Cloud9 IDE, aprite il file. `hello/Program.cs`
Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `Program.cs`.
```
using System;
namespace hello
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Please provide 2 numbers");
return;
}
Console.WriteLine("Hello, World!");
Console.WriteLine("The sum of 2 and 3 is 5.");
int sum = Int32.Parse(args[0]) + Int32.Parse(args[1]);
Console.WriteLine("The sum of {0} and {1} is {2}.",
args[0], args[1], sum);
}
}
}
```
## Fase 5: costruire ed eseguire il codice
In questa fase è necessario creare il progetto e le relative dipendenze in un set di file binari, incluso un file eseguibile dell'applicazione. Quindi esegui l'applicazione.
1. Nell'IDE, create un builder per.NET come segue.
1. Sulla barra dei menu seleziona **Run (Esegui), Build System (Compila sistema), New Build System (Nuovo sistema compilazione)**.
1. Nella scheda **My Builder.build**, sostituisci i contenuti della scheda con il seguente codice.
```
{
"cmd" : ["dotnet", "build"],
"info" : "Building..."
}
```
1. Selezionare **File, Save As (File, Salva come)**.
1. In **Filename (Nome file)**, digita `.NET.build`.
1. In **Folder (Cartella)**, digita `/.c9/builders`.
1. Scegli **Save** (Salva).
1. Con il contenuto del `Program.cs` file visualizzato nell'editor, scegliete **Run, Build System, .NET**. Seleziona quindi **Run, Build (Esegui, Crea)**.
Questo generatore aggiunge una sottodirectory denominata `bin` e aggiunge una sottodirectory denominata `Debug` alla sottodirectory `hello/obj`. Prendi nota dei seguenti tre file chiave.
+ Il file `hello/bin/Debug/netcoreapp3.1/hello.dll` è il file eseguibile dell'applicazione.
+ Il file `hello/bin/Debug/netcoreapp3.1/hello.deps.json` elenca le dipendenze dell'applicazione.
+ Il file `hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json` specifica il runtime condiviso e la relativa versione per l'applicazione.
**Nota**
Il nome della cartella,`netcoreapp3.1`, riflette la versione di.NET SDK utilizzata in questo esempio. Potresti visualizzare un numero diverso nel nome della cartella a seconda della versione installata.
1. Crea un runner per.NET come segue.
1. Nella barra dei menu scegli **Run, Run With, New Runner (Esegui, Esegui con, Nuova esecuzione)**.
1. Nella scheda **My Runner.run**, sostituisci i contenuti della scheda con il seguente codice.
```
{
"cmd" : ["dotnet", "run", "$args"],
"working_dir": "$file_path",
"info" : "Running..."
}
```
1. Selezionare **File, Save As (File, Salva come)**.
1. In **Filename (Nome file)**, digita `.NET.run`.
1. In **Folder (Cartella)**, digita `/.c9/runners`.
1. Scegli **Save** (Salva).
1. Esegui l'applicazione con due numeri interi da aggiungere (ad esempio, `5` e `9`) come descritto di seguito.
1. Con i contenuti del file `Program.cs` visualizzati nell'editor, scegli **Run, Run Configurations, New Run Configuration (Esegui, Configurazioni di esecuzione, Nuova configurazione di esecuzione)**.
1. **Nella scheda **[Nuovo] - Inattivo**, scegli **Runner: Auto**, quindi scelgi.NET.**
1. Nella casella **Command (Comando)**, digita `hello 5 9`.
1. Scegli **Esegui**.
Per impostazione predefinita, questo runner indica a .NET di eseguire il `hello.dll` file nella directory. `hello/bin/Debug/netcoreapp3.1`
Confronta l'output con quanto segue.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Passaggio 6: Creare e configurare un progetto di applicazione console.NET che utilizzi il AWS SDK per .NET
Puoi migliorare questo esempio per utilizzare il bucket Amazon S3, AWS SDK per .NET elencare i bucket disponibili e quindi eliminare il bucket appena creato.
In questo nuovo progetto, aggiungi un riferimento ad AWS SDK per .NET. AWS SDK per .NET Fornisce un modo pratico per interagire con AWS servizi come Amazon S3, dal tuo codice.NET. È quindi possibile configurare la gestione AWS delle credenziali nel proprio ambiente. AWS SDK per .NET Ha bisogno di queste credenziali per interagire con AWS i servizi.
### Per creare il progetto
1. Crea un progetto di applicazione console.NET. A tale scopo, esegui la CLI.NET con il **`new`**comando, specificando il tipo di modello di progetto dell'applicazione console e il linguaggio di programmazione da utilizzare.
L'opzione `-n` indica che il progetto viene emesso in una nuova directory, `s3`. Passiamo quindi a tale directory.
```
dotnet new console -lang C# -n s3
cd s3
```
1. Aggiungi un riferimento di progetto al pacchetto Amazon S3 nell' AWS SDK per .NET. A tale scopo, esegui la CLI.NET con il **`add package`**comando, specificando il nome del pacchetto Amazon S3 in. NuGet (NuGetdefinisce il modo in cui i pacchetti per.NET vengono creati, ospitati e utilizzati e fornisce gli strumenti per ciascuno di questi ruoli.)
```
dotnet add package AWSSDK.S3
```
Quando aggiungi un riferimento al progetto al pacchetto Amazon S3, aggiunge NuGet anche un riferimento al progetto al resto del. AWS SDK per .NET
**Nota**
Per i nomi e le versioni di altri pacchetti AWS correlati in NuGet, consulta i [NuGetpacchetti etichettati con aws-sdk](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22) sul sito Web. NuGet
### Per configurare la gestione delle credenziali AWS
Ogni volta che si utilizza il AWS SDK per .NET per chiamare un AWS servizio, è necessario fornire un set di AWS credenziali con la chiamata. Queste credenziali determinano se AWS SDK per .NET dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.
Per archiviare le credenziali nell'ambiente, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md) e torna a questo argomento.
*Per ulteriori informazioni, consulta [Configurazione delle AWS credenziali](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html) nella Guida per gli sviluppatori.AWS SDK per .NET *
## Passaggio 7: Aggiungere AWS il codice SDK
In questa fase si aggiunge il codice per interagire con Amazon S3 e creare un bucket, eliminare il bucket appena creato ed elencare i bucket disponibili.
Dalla finestra **Ambiente dell'** AWS Cloud9 IDE, apri il `s3/Program.cs` file. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `Program.cs`.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;
using System;
using System.Threading.Tasks;
namespace s3
{
class Program
{
async static Task Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Usage: ");
Console.WriteLine("Example: my-test-bucket us-east-2");
return;
}
if (args[1] != "us-east-2") {
Console.WriteLine("Cannot continue. The only supported AWS Region ID is " +
"'us-east-2'.");
return;
}
var bucketRegion = RegionEndpoint.USEast2;
// Note: You could add more valid AWS Regions above as needed.
using (var s3Client = new AmazonS3Client(bucketRegion)) {
var bucketName = args[0];
// Create the bucket.
try
{
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Cannot continue. Cannot create bucket. \n" +
"A bucket named '{0}' already exists.", bucketName);
return;
} else {
Console.WriteLine("\nCreating the bucket named '{0}'...", bucketName);
await s3Client.PutBucketAsync(bucketName);
}
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
// Confirm that the bucket was created.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Created the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Did not create the bucket named '{0}'.", bucketName);
}
// Delete the bucket.
Console.WriteLine("\nDeleting the bucket named '{0}'...", bucketName);
await s3Client.DeleteBucketAsync(bucketName);
// Confirm that the bucket was deleted.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Did not delete the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Deleted the bucket named '{0}'.", bucketName);
};
// List current buckets.
Console.WriteLine("\nMy buckets now are:");
var response = await s3Client.ListBucketsAsync();
foreach (var bucket in response.Buckets)
{
Console.WriteLine(bucket.BucketName);
}
}
}
}
}
```
## Passaggio 8: Compila ed esegui il AWS codice SDK
In questa fase è necessario creare il progetto e le relative dipendenze in un set di file binari, incluso un file eseguibile dell'applicazione. Quindi esegui l'applicazione.
1. Compilare il progetto. Per eseguire questa operazione con i contenuti del file `s3/Program.cs` visualizzati nell'editor, sulla barra dei menu scegli **Run, Build (Esegui, Crea)**.
1. Esegui l'applicazione con il nome del bucket Amazon S3 da creare e l'ID della regione AWS in cui creare il bucket (ad esempio `my-test-bucket` e `us-east-2`) come descritto di seguito.
1. Con i contenuti del file `s3/Program.cs` ancora visualizzati nell'editor, scegli **Run, Run Configurations, New Run Configuration (Esegui, Configurazioni di esecuzione, Nuova configurazione di esecuzione)**.
1. **Nella scheda **[Nuovo] - Idle**, scegli **Runner: Auto**, quindi selezione.NET.**
1. Nella casella **Comando**, digita il nome dell'applicazione, il nome del bucket Amazon S3 da creare e l'ID della AWS regione in cui creare il bucket (ad esempio,). `s3 my-test-bucket us-east-2`
1. Scegli **Esegui**.
Per impostazione predefinita, questo runner indica .NET di eseguire il file nella `s3.dll` directory. `s3/bin/Debug/netcoreapp3.1`
Confronta i tuoi risultati con il seguente output.
```
Creating a new bucket named 'my-test-bucket'...
Created the bucket named 'my-test-bucket'.
Deleting the bucket named 'my-test-bucket'...
Deleted the bucket named 'my-test-bucket'.
My buckets now are:
```
## Fase 9: Pulizia
Per evitare addebiti continui AWS sul tuo account dopo aver finito di usare questo esempio, dovresti eliminare l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# Tutorial Node.js per AWS Cloud9
Questo tutorial consente di eseguire alcuni script Node.js in un ambiente di AWS Cloud9 sviluppo.
L'esecuzione di questo tutorial e la creazione di questo esempio potrebbero comportare addebiti sul tuo AWS account. Questi includono eventuali addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta i prezzi di [Amazon e EC2 i prezzi](https://aws.amazon.com/ec2/pricing/) di [Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-nodejs-prereqs)
+ [Fase 1: installare gli strumenti necessari](#sample-nodejs-install)
+ [Fase 2: aggiungere un codice](#sample-nodejs-code)
+ [Fase 3: eseguire il codice](#sample-nodejs-run)
+ [Passaggio 4: installa e configura l' AWS SDK per JavaScript in Node.js](#sample-nodejs-sdk)
+ [Passaggio 5: aggiungere il codice SDK AWS](#sample-nodejs-sdk-code)
+ [Passaggio 6: Esegui il codice AWS SDK](#sample-nodejs-sdk-run)
+ [Passaggio 7: eseguire l'eliminazione](#sample-nodejs-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di AWS Cloud9 EC2 sviluppo esistente.** Questo esempio presuppone che tu disponga già di un EC2 ambiente connesso a un' EC2 istanza Amazon che esegue Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare gli strumenti necessari
In questa fase, viene installato Node.js, indispensabile per eseguire l'esempio.
1. In una sessione di terminale nell' AWS Cloud9 IDE, verificate se Node.js è già installato eseguendo il **`node --version`**comando. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale). In caso di esito positivo, l'output includerà il numero di versione di Node.js. Se Node.js è installato, passa alla [Fase 2: aggiungere un codice](#sample-nodejs-code).
1. Esegui il comando ** `yum update` ** per (Amazon Linux) o ** `apt update` ** per (Ubuntu Server) per verificare che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug più recenti.
Per Amazon Linux:
```
sudo yum -y update
```
Per Ubuntu Server:
```
sudo apt update
```
1. Per installare Node.js, inizia eseguendo questo comando per scaricare Node Version Manager (nvm). (nvm è un semplice script di shell Bash utile per installare e gestire le versioni di Node.js. Per ulteriori informazioni, consulta [Node Version Manager sul sito](https://github.com/creationix/nvm/blob/master/README.md) Web.) GitHub
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
```
1. Per iniziare a utilizzare nvm, chiudi la sessione del terminale e avviala nuovamente oppure trova il file `~/.bashrc` che contiene i comandi per scaricare nvm.
```
. ~/.bashrc
```
1. Esegui questo comando per installare Node.js 16 su Amazon Linux 2, Amazon Linux 1 e Ubuntu 18.04. Le istanze di Amazon Linux 1 e Ubuntu 18.04 supportano solo Node.js fino alla v16.
```
nvm install 16
```
Esegui questo comando per installare l'ultima versione di Node.js su Amazon Linux 2023 e Ubuntu 22.04:
```
nvm install --lts && nvm alias default lts/*
```
**Nota**
AWS Cloud9 Nell'immagine AL2 023 più recente è installato Node.js 20 e nell' AWS Cloud9 immagine Amazon Linux 2 più recente è installato Node.js 18. Se desideri installare Node.js 18 su Amazon Linux 2 AWS Cloud9 manualmente, esegui il seguente comando nel terminale AWS Cloud9 IDE:
```
C9_NODE_INSTALL_DIR=~/.nvm/versions/node/v18.17.1
C9_NODE_URL=https://d3kgj69l4ph6w4.cloudfront.net/static/node-amazon/node-v18.17.1-linux-x64.tar.gz
mkdir -p $C9_NODE_INSTALL_DIR
curl -fSsl $C9_NODE_URL | tar xz --strip-components=1 -C "$C9_NODE_INSTALL_DIR"
nvm alias default v18.17.1
nvm use default
echo -e 'nvm use default' >> ~/.bash_profile
```
## Fase 2: aggiungere un codice
Nell' AWS Cloud9 IDE, crea un file con questo contenuto e salva il file con il nome`hello.js`. (Per creare un file, nella barra dei menu scegli **File**, **New File** (Nuovo file). Per salvare il file, scegli **File**,**Save** (Salva)).
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
var sum = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## Fase 3: eseguire il codice
1. Nell' AWS Cloud9 IDE, nella barra dei menu, scegli **Esegui, Esegui** **configurazioni**, **Nuova configurazione di esecuzione**.
1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Node.js**.
1. Per **Command (Comando)**, digitare `hello.js 5 9`. Nel codice, `5` rappresenta `process.argv[2]`, mentre `9` rappresenta `process.argv[3]`. (`process.argv[0]` rappresenta il nome del runtime (`node`) e `process.argv[1]` rappresenta il nome del file (`hello.js`).)
1. Seleziona il pulsante **Run (Esegui)** e confronta gli output.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Output di Node.js dopo l'esecuzione del codice nell'IDE AWS Cloud9\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## Passaggio 4: installa e configura l' AWS SDK per JavaScript in Node.js
Quando esegui gli script Node.js AWS Cloud9, puoi scegliere tra AWS SDK per la JavaScript versione 3 (V3) e l' AWS SDK precedente per la JavaScript versione 2 (V2). Come per la versione 2, la versione 3 consente di lavorare facilmente con Amazon Web Services, ma è stata scritta TypeScript e aggiunge diverse funzionalità richieste di frequente, come i pacchetti modulari.
------
#### [ AWS SDK for JavaScript (V3) ]
Puoi migliorare questo esempio per utilizzare l' AWS SDK di Node.js per JavaScript creare un bucket Amazon S3, elencare i bucket disponibili e quindi eliminare il bucket appena creato.
In questa fase, installi e configuri il modulo client di servizio Amazon S3 dell' AWS SDK per JavaScript Node.js, che fornisce un modo conveniente per interagire con il AWS servizio Amazon S3, dal tuo codice. JavaScript
Se desideri utilizzare altri AWS servizi, devi installarli separatamente. Per ulteriori informazioni sull'installazione AWS dei moduli, consultate [la *AWS Developer Guide (V3)*](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/working-with-services). Per informazioni su come iniziare a usare Node.js e AWS SDK for JavaScript (V3), consulta Guida [introduttiva a Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure) nella *AWS SDK for JavaScript Developers Guide* (V3).
Dopo aver installato l' AWS SDK for JavaScript in Node.js, devi configurare la gestione delle credenziali nel tuo ambiente. L' AWS SDK per JavaScript Node.js richiede queste credenziali per interagire con i servizi. AWS
**Per installare l' AWS SDK per in Node.js JavaScript **
Utilizza npm per eseguire il comando ** `install` **.
```
npm install @aws-sdk/client-s3
```
Per ulteriori informazioni, consulta [Installazione dell'SDK for JavaScript nella Guida per](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html#installing-jssdk) gli *AWS SDK per JavaScript sviluppatori*.
**Per configurare la gestione delle credenziali nell'ambiente**
Ogni volta che si utilizza l' AWS SDK for JavaScript in Node.js per chiamare un AWS servizio, è necessario fornire un set di credenziali con la chiamata. Queste credenziali determinano se l' AWS SDK per JavaScript Node.js dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.
In questa fase si archiviano le credenziali all'interno dell'ambiente A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento.
Per ulteriori informazioni consulta [Impostazione delle credenziali su Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) nella *Guida per gli sviluppatori di AWS SDK per JavaScript *.
------
#### [ AWS SDK for JavaScript (V2) ]
Puoi migliorare questo esempio per utilizzare l' AWS SDK di Node.js per JavaScript creare un bucket Amazon S3, elencare i bucket disponibili e quindi eliminare il bucket appena creato.
In questo passaggio, installerai e configurerai l' AWS SDK per JavaScript in Node.js, che fornisce un modo comodo per interagire con AWS servizi come Amazon S3, dal JavaScript tuo codice. Dopo aver installato l' AWS SDK for JavaScript in Node.js, devi configurare la gestione delle credenziali nel tuo ambiente. L' AWS SDK per JavaScript Node.js richiede queste credenziali per interagire con i servizi. AWS
**Per installare l' AWS SDK per in Node.js JavaScript **
Utilizza npm per eseguire il comando ** `install` **.
```
npm install aws-sdk
```
Per ulteriori informazioni, consulta [Installazione dell'SDK for JavaScript nella Guida per](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) gli *AWS SDK per JavaScript sviluppatori*.
**Per configurare la gestione delle credenziali nell'ambiente**
Ogni volta che si utilizza l' AWS SDK for JavaScript in Node.js per chiamare un AWS servizio, è necessario fornire un set di credenziali con la chiamata. Queste credenziali determinano se l' AWS SDK per JavaScript Node.js dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.
In questa fase si archiviano le credenziali all'interno dell'ambiente A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento.
Per ulteriori informazioni consulta [Impostazione delle credenziali su Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) nella *Guida per gli sviluppatori di AWS SDK per JavaScript *.
------
## Passaggio 5: aggiungere il codice SDK AWS
------
#### [ AWS SDK for JavaScript (V3) ]
In questa fase si aggiunge altro codice, questa volta per interagire con Amazon S3 e creare un bucket, elencare i bucket disponibili ed eliminare il bucket appena creato. Potrai eseguire questo codice più tardi.
Nell' AWS Cloud9 IDE, crea un file con questo contenuto e salva il file con il nome`s3.js`.
```
import {
CreateBucketCommand,
DeleteBucketCommand,
ListBucketsCommand,
S3Client,
} from "@aws-sdk/client-s3";
const wait = async (milliseconds) => {
return new Promise((resolve) => setTimeout(resolve, milliseconds));
};
export const main = async () => {
const client = new S3Client({});
const now = Date.now();
const BUCKET_NAME = `easy-bucket-${now.toString()}`;
const createBucketCommand = new CreateBucketCommand({ Bucket: BUCKET_NAME });
const listBucketsCommand = new ListBucketsCommand({});
const deleteBucketCommand = new DeleteBucketCommand({ Bucket: BUCKET_NAME });
try {
console.log(`Creating bucket ${BUCKET_NAME}.`);
await client.send(createBucketCommand);
console.log(`${BUCKET_NAME} created`);
await wait(2000);
console.log(`Here are your buckets:`);
const { Buckets } = await client.send(listBucketsCommand);
Buckets.forEach((bucket) => {
console.log(` • ${bucket.Name}`);
});
await wait(2000);
console.log(`Deleting bucket ${BUCKET_NAME}.`);
await client.send(deleteBucketCommand);
console.log(`${BUCKET_NAME} deleted`);
} catch (err) {
console.error(err);
}
};
main();
```
------
#### [ AWS SDK for JavaScript (V2) ]
In questa fase si aggiunge altro codice, questa volta per interagire con Amazon S3 e creare un bucket, elencare i bucket disponibili ed eliminare il bucket appena creato. Potrai eseguire questo codice più tardi.
Nell' AWS Cloud9 IDE, create un file con questo contenuto e salvate il file con il nome`s3.js`.
```
if (process.argv.length < 4) {
console.log(
"Usage: node s3.js \n" +
"Example: node s3.js my-test-bucket us-east-2"
);
process.exit(1);
}
var AWS = require("aws-sdk"); // To set the AWS credentials and region.
var async = require("async"); // To call AWS operations asynchronously.
AWS.config.update({
region: region,
});
var s3 = new AWS.S3({ apiVersion: "2006-03-01" });
var bucket_name = process.argv[2];
var region = process.argv[3];
var create_bucket_params = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region,
},
};
var delete_bucket_params = { Bucket: bucket_name };
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback) {
s3.listBuckets(function (err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (var i = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback) {
console.log("\nCreating a bucket named " + bucket_name + "...\n");
s3.createBucket(create_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback) {
console.log("\nDeleting the bucket named " + bucket_name + "...\n");
s3.deleteBucket(delete_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets,
]);
```
------
## Passaggio 6: Esegui il codice AWS SDK
1. Abilita il codice per chiamare le operazioni Amazon S3 in modo asincrono utilizzando npm per eseguire il comando ** `install` **.
```
npm install async
```
1. Nell' AWS Cloud9 IDE, nella barra dei menu, scegli **Esegui, Esegui** **configurazioni**, **Nuova configurazione di esecuzione**.
1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Node.js**.
1. **Se stai usando AWS SDK per JavaScript (V3), per Command type.** `s3.js` Se utilizzi AWS SDK per Javascript (v2), per il tipo **Command**`s3.js my-test-bucket us-east-2`, `my-test-bucket` dov'è il nome del bucket che desideri creare e quindi eliminare e `us-east-2` l'ID della AWS regione in cui desideri creare il bucket. Per ulteriori informazioni IDs, consulta [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) nel. *Riferimenti generali di Amazon Web Services*
**Nota**
I nomi dei bucket Amazon S3 devono essere univoci per tutti gli account, AWS non solo per il tuo account. AWS
1. Seleziona il pulsante **Run (Esegui)** e confronta gli output.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Passaggio 7: eseguire l'eliminazione
Per evitare addebiti continui sul tuo AWS account dopo aver finito di utilizzare questo esempio, devi eliminare l'ambiente. Per istruzioni, consultare [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# Tutorial PHP per AWS Cloud9
Questo tutorial consente di eseguire alcuni script PHP in un ambiente di sviluppo. AWS Cloud9
Seguire questo tutorial e creare questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-php-prereqs)
+ [Fase 1: installare gli strumenti necessari](#sample-php-install)
+ [Fase 2: aggiungere un codice](#sample-php-code)
+ [Fase 3: eseguire il codice](#sample-php-run)
+ [Fase 4: Installare e configurare AWS SDK per PHP](#sample-php-sdk)
+ [Passaggio 5: Aggiungere AWS il codice SDK](#sample-php-sdk-code)
+ [Passaggio 6: Esegui il codice AWS SDK](#sample-php-sdk-run)
+ [Fase 7: pulire](#sample-php-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare gli strumenti necessari
In questa fase, installerai PHP, indispensabile per eseguire l'esempio.
**Nota**
Con la procedura seguente, è possibile installare solo PHP. Per installare strumenti correlati come un server Web Apache e un database MySQL, [consulta Tutorial: Installazione di un server Web LAMP su Amazon Linux nella Guida per l'utente di Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-LAMP.html) *EC2*.
1. In una sessione di terminale nell' AWS Cloud9 IDE, verifica se PHP è già installato eseguendo il comando. **`php --version`** Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale). Se è già installato, l'output contiene il numero di versione di PHP: Se PHP è installato, passa alla [Fase 2: aggiungere un codice](#sample-php-code).
1. Esegui il comando ** `yum update` ** per (Amazon Linux) o ** `apt update` ** per (Ubuntu Server) per verificare che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug più recenti.
Per Amazon Linux 2 e Amazon Linux:
```
sudo yum -y update
```
Per Ubuntu Server:
```
sudo apt update
```
1. Installa PHP eseguendo il comando ** `install` **.
Per Amazon Linux 2:
```
sudo amazon-linux-extras install -y php7.2
```
Per Amazon Linux:
```
sudo yum -y install php72
```
**Nota**
È possibile visualizzare la versione di Amazon Linux con il comando seguente:
```
cat /etc/system-release
```
Per Ubuntu Server:
```
sudo apt install -y php php-xml
```
Per ulteriori informazioni, consulta [Installazione e configurazione](http://php.net/manual/en/install.php) sul sito Web di PHP.
## Fase 2: aggiungere un codice
Nell' AWS Cloud9 IDE, create un file con questo contenuto e salvate il file con il nome`hello.php`. (Per creare un file, nella barra dei menu scegli **File**, **New File** (Nuovo file). Per salvare il file, scegli **File**, **Save** (Salva), digita `hello.php` in **Filename** (Nome file), quindi scegli **Save** (Salva)).
```
```
**Nota**
Il codice precedente non si basa su alcun file esterno. Tuttavia, se includi o richiedi altri file PHP nel tuo file e desideri utilizzare tali file AWS Cloud9 per completare il codice durante la digitazione, attiva l'impostazione **Project, PHP Support, Enable PHP code completion in **Preferenze**,** quindi aggiungi i percorsi di quei file all'impostazione **Project, PHP Support, PHP** Completion Include Paths. Per visualizzare e modificare le preferenze, seleziona **AWS Cloud9, Preferences** (Preferenze) nella barra dei menu.
## Fase 3: eseguire il codice
1. **Nell' AWS Cloud9 IDE, nella barra dei menu, scegliete **Esegui, Esegui** **configurazioni, Nuova configurazione di esecuzione**.**
1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **PHP (cli) (PHP (interfaccia a riga di comando)**.
1. Per **Command (Comando)**, digitare `hello.php 5 9`. Nel codice, `5` rappresenta `$argv[1]`, mentre `9` rappresenta `$argv[2]`. (`$argv[0]` rappresenta il nome del file (`hello.php`).)
1. Seleziona il pulsante **Run (Esegui)** e confronta gli output.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Risultato dell'esecuzione del codice PHP nell'IDE AWS Cloud9\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/ide-php-simple.png)
## Fase 4: Installare e configurare AWS SDK per PHP
Puoi migliorare questo esempio per utilizzare il bucket Amazon S3, AWS SDK per PHP elencare i bucket disponibili e quindi eliminare il bucket appena creato.
In questa fase, installi e configuri il AWS SDK per PHP, che fornisce un modo conveniente per interagire con AWS servizi come Amazon S3, dal tuo codice PHP. [Prima di poter installare AWS SDK per PHP, è necessario installare Composer.](https://getcomposer.org/) Dopo aver installato AWS SDK per PHP, è necessario configurare la gestione delle credenziali nel proprio ambiente. Queste credenziali sono AWS SDK per PHP necessarie per interagire con AWS i servizi.
### Per installare Composer
Esegui il comando ** `curl` ** in modalità silenziosa (`-s`) e mostra le opzioni di errore (`-S`), indirizzando il programma di installazione di Composer in un file di archivio PHP (PHAR), convenzionalmente denominato `composer.phar`.
```
curl -sS https://getcomposer.org/installer | php
```
### Per installare il AWS SDK per PHP
Per Ubuntu Server, installa ulteriori pacchetti che Composer necessita per installare l' AWS SDK per PHP.
```
sudo apt install -y php-xml php-curl
```
Per Amazon Linux o Ubuntu Server, utilizza il comando **php** per eseguire il programma di installazione di Composer e installare AWS SDK per PHP.
```
php composer.phar require aws/aws-sdk-php
```
Questo comando crea diverse cartelle e file nell'ambiente. Il file principale che utilizzerai è `autoload.php`, che si trova nella cartella `vendor` dell'ambiente.
**Nota**
Dopo l'installazione, Composer potrebbe suggerire l'installazione di ulteriori dipendenze. A questo proposito puoi utilizzare un comando come il seguente, specificando l'elenco delle dipendenze da installare. Ad esempio, il comando seguente indica a Composer di installare il seguente elenco di dipendenze.
```
php composer.phar require psr/log ext-curl doctrine/cache aws/aws-php-sns-message-validator
```
Per ulteriori informazioni, consulta [Installazione](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/installation.html) in *Guida per gli sviluppatori di AWS SDK per PHP *.
### Per configurare la gestione delle credenziali nell'ambiente
Ogni volta che si utilizza il AWS SDK per PHP per chiamare un AWS servizio, è necessario fornire un set di credenziali con la chiamata. Queste credenziali determinano se AWS SDK per PHP dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.
In questa fase si archiviano le credenziali all'interno dell'ambiente A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento.
Per ulteriori informazioni, consulta la sezione "Creazione di un client" di [Utilizzo di base](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/basic-usage.html) in *Guida per gli sviluppatori di AWS SDK per PHP *.
## Passaggio 5: Aggiungere AWS il codice SDK
In questa fase si aggiunge altro codice, questa volta per interagire con Amazon S3 e creare un bucket, elencare i bucket disponibili ed eliminare il bucket appena creato. Potrai eseguire questo codice più tardi.
Nell' AWS Cloud9 IDE, crea un file con questo contenuto e salva il file con il nome`s3.php`.
```
\n" .
"Example: php s3.php America/Los_Angeles my-test-bucket us-east-2");
}
$timeZone = $argv[1];
$bucketName = $argv[2];
$region = $argv[3];
date_default_timezone_set($timeZone);
$s3 = new Aws\S3\S3Client([
'region' => $region,
'version' => '2006-03-01'
]);
# Lists all of your available buckets in this AWS Region.
function listMyBuckets($s3)
{
print("\nMy buckets now are:\n");
$promise = $s3->listBucketsAsync();
$result = $promise->wait();
foreach ($result['Buckets'] as $bucket) {
print("\n");
print($bucket['Name']);
}
}
listMyBuckets($s3);
# Create a new bucket.
print("\n\nCreating a new bucket named '$bucketName'...\n");
try {
$promise = $s3->createBucketAsync([
'Bucket' => $bucketName,
'CreateBucketConfiguration' => [
'LocationConstraint' => $region
]
]);
$promise->wait();
} catch (Exception $e) {
if ($e->getCode() == 'BucketAlreadyExists') {
exit("\nCannot create the bucket. " .
"A bucket with the name '$bucketName' already exists. Exiting.");
}
}
listMyBuckets($s3);
# Delete the bucket you just created.
print("\n\nDeleting the bucket named '$bucketName'...\n");
$promise = $s3->deleteBucketAsync([
'Bucket' => $bucketName
]);
$promise->wait();
listMyBuckets($s3);
?>
```
## Passaggio 6: Esegui il codice AWS SDK
1. Nell' AWS Cloud9 IDE, nella barra dei menu, scegli **Esegui, Esegui** **configurazioni**, **Nuova configurazione di esecuzione**.
1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **PHP (cli) (PHP (interfaccia a riga di comando)**.
1. In **Command (Comando)**, digita `s3.php America/Los_Angeles my-test-bucket us-east-2`, dove:
+ `America/Los_Angeles` è l'ID del tuo fuso orario predefinito. Per ulteriori informazioni IDs, consulta l'[Elenco dei fusi orari supportati](http://php.net/manual/en/timezones.php) sul sito Web di PHP.
+ `my-test-bucket` è il nome del bucket che vuoi creare e quindi eliminare.
**Nota**
I nomi dei bucket Amazon S3 devono essere univoci per tutti gli account, AWS non solo per il tuo account. AWS
+ `us-east-2`è l'ID della AWS regione in cui desideri creare il bucket. Per ulteriori informazioni IDs, consulta [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) nel. *Riferimenti generali di Amazon Web Services*
1. Seleziona il pulsante **Run (Esegui)** e confronta gli output.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Fase 7: pulire
Per evitare addebiti continui AWS sul tuo account dopo aver finito di utilizzare questo esempio, devi eliminare l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
### Risoluzione dei problemi con PHP runner per AWS Cloud9
Nel caso in cui si verifichino problemi con il runner PHP CLI, è necessario assicurarsi che il runner sia impostato su PHP e che la modalità debugger sia abilitata.
# AWS SDK per Ruby in AWS Cloud9
Per informazioni sull'utilizzo AWS Cloud9 con l' AWS SDK per Ruby[, AWS Cloud9 consulta Using AWS with the SDK for Ruby nella SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html) Developer *AWS Guide*.
**Nota**
Seguire questo tutorial potrebbe comportare addebiti sul tuo account. AWS Questi includono eventuali addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta i prezzi di [Amazon e EC2 i prezzi](https://aws.amazon.com/ec2/pricing/) di [Amazon S3](https://aws.amazon.com/s3/pricing/).
# Vai al tutorial per AWS Cloud9
Questo tutorial ti consente di eseguire del codice Go in un ambiente di AWS Cloud9 sviluppo.
Seguire questo tutorial e creare questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-go-prereqs)
+ [Fase 1: installare gli strumenti necessari](#sample-go-install)
+ [Fase 2: aggiungere un codice](#sample-go-code)
+ [Fase 3: eseguire il codice](#sample-go-run)
+ [Fase 4: Installare e configurare AWS SDK per Go](#sample-go-sdk)
+ [Passaggio 5: Aggiungere AWS il codice SDK](#sample-go-sdk-code)
+ [Passaggio 6: Esegui il codice AWS SDK](#sample-go-sdk-run)
+ [Fase 7: pulire](#sample-go-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare gli strumenti necessari
In questa fase, viene installato e configurato Go, indispensabile per eseguire l'esempio.
1. In una sessione terminale nell' AWS Cloud9 IDE, verifica se Go è già installato eseguendo il **`go version`**comando. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale). In caso di esito positivo, l'output includerà il numero di versione di Go. In caso contrario, verrà prodotto un messaggio di errore. Se Go è installato, passa alla [Fase 2: aggiungere un codice](#sample-go-code).
1. Esegui il comando ** `yum update` ** per (Amazon Linux) o ** `apt update` ** per (Ubuntu Server) per verificare che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug più recenti.
Per Amazon Linux:
```
sudo yum -y update
```
Per Ubuntu Server:
```
sudo apt update
```
1. Per installare Go, esegui questi comandi, uno alla volta.
```
wget https://storage.googleapis.com/golang/go1.9.3.linux-amd64.tar.gz # Download the Go installer.
sudo tar -C /usr/local -xzf ./go1.9.3.linux-amd64.tar.gz # Install Go.
rm ./go1.9.3.linux-amd64.tar.gz # Delete the installer.
```
I comandi precedenti presuppongono l'utilizzo della versione stabile di Go più recente, al momento della redazione di questo argomento. Per ulteriori informazioni, vedi [Download](https://golang.org/dl/) nel sito Web del linguaggio di programmazione Go.
1. Aggiungi il percorso del file binario Go alla variabile di ambiente `PATH`, come indicato di seguito.
1. Apri il file del profilo shell (ad esempio, `~/.bashrc`) per la modifica.
1. Alla fine di questa riga di codice, digita quanto segue. Il codice dovrebbe avere questo aspetto.
```
PATH=$PATH:/usr/local/go/bin
```
1. Salvare il file.
1. Indica l'origine del file `~/.bashrc`, in modo che il terminale sia in grado di trovare il file binario GO usato come riferimento.
```
. ~/.bashrc
```
1. Conferma che Go è stato installato e configurato correttamente, eseguendo il comando ** `go version` **. In caso di esito positivo, l'output includerà il numero di versione di Go.
## Fase 2: aggiungere un codice
Nell' AWS Cloud9 IDE, crea un file con questo contenuto e salva il file con il nome`hello.go`. (Per creare un file, nella barra dei menu scegli **File**, **New File** (Nuovo file). Per salvare il file, scegli **File**,**Save** (Salva)).
```
package main
import (
"fmt"
"os"
"strconv"
)
func main() {
fmt.Printf("Hello, World!\n")
fmt.Printf("The sum of 2 and 3 is 5.\n")
first, _ := strconv.Atoi(os.Args[1])
second, _ := strconv.Atoi(os.Args[2])
sum := first + second
fmt.Printf("The sum of %s and %s is %s.",
os.Args[1], os.Args[2], strconv.Itoa(sum))
}
```
## Fase 3: eseguire il codice
1. Nell' AWS Cloud9 IDE, nella barra dei menu, scegli **Esegui, Esegui** **configurazioni**, **Nuova configurazione di esecuzione**.
1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Go**.
**Nota**
Se **Go** non è disponibile, puoi creare un'esecuzione personalizzata per Go.
Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **New Runner (Nuova esecuzione)**.
Nella scheda **My Runner.run**, sostituisci i contenuti della scheda con questo codice.
```
{
"cmd" : ["go", "run", "$file", "$args"],
"info" : "Running $project_path$file_name...",
"selector" : "source.go"
}
```
Nella barra dei menu seleziona **File**, **Save As (Salva con nome)** e salva il file come `Go.run` nella cartella `/.c9/runners`.
Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Go**.
Seleziona la scheda **hello.go** per attivarlo.
1. Per **Command (Comando)**, digitare `hello.go 5 9`. Nel codice, `5` rappresenta `os.Args[1]` e `9` rappresenta `os.Args[2]`.
![\[Risultato dell'esecuzione del codice Go nell'IDE AWS Cloud9\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/ide-go-simple.png)
1. Seleziona il pulsante **Run (Esegui)** e confronta gli output.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Fase 4: Installare e configurare AWS SDK per Go
Puoi migliorare questo esempio per utilizzare il bucket Amazon S3, AWS SDK per Go elencare i bucket disponibili e quindi eliminare il bucket appena creato.
In questa fase, installi e configuri il AWS SDK per Go, che fornisce un modo conveniente per interagire con AWS servizi come Amazon S3, dal tuo codice Go. Prima di installare l' AWS SDK per Go, è necessario impostare la variabile di ambiente `GOPATH`. Dopo avere installato AWS SDK per Go e impostato la variabile di ambiente `GOPATH`, devi configurare la gestione delle credenziali nell'ambiente. AWS SDK per Go Ha bisogno di queste credenziali per interagire con AWS i servizi.
### Per impostare la variabile di ambiente GOPATH
1. Apri il file `~/.bashrc` per la modifica.
1. Dopo l'ultima riga del file, digita questo codice.
```
GOPATH=~/environment/go
export GOPATH
```
1. Salvare il file.
1. Indica l'origine del file `~/.bashrc` in modo che il terminale sia in grado di trovare la variabile di ambiente `GOPATH` usata come riferimento.
```
. ~/.bashrc
```
1. Verifica che l'impostazione della variabile di ambiente `GOPATH` sia corretta eseguendo il comando ** `echo $GOPATH` **. In caso di esito positivo, l'output è `/home/ec2-user/environment/go` o `/home/ubuntu/environment/go`.
### Per installare il AWS SDK per Go
Esegui il **`go get`**comando, specificando la posizione della AWS SDK per Go fonte.
```
go get -u github.com/aws/aws-sdk-go/...
```
Go installa la AWS SDK per Go sorgente nella posizione specificata dalla variabile di `GOPATH` ambiente, che è la `go` cartella dell'ambiente.
### Per configurare la gestione delle credenziali nell'ambiente
Ogni volta che si utilizza il AWS SDK per Go per chiamare un AWS servizio, è necessario fornire un set di credenziali con la chiamata. Queste credenziali determinano se AWS SDK per Go dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.
In questa fase si archiviano le credenziali all'interno dell'ambiente A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento.
Per ulteriori informazioni, consulta [Specifying Credentials](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials) nella *AWS SDK per Go Developer Guide*.
## Passaggio 5: Aggiungere AWS il codice SDK
In questa fase si aggiunge altro codice, questa volta per interagire con Amazon S3 e creare un bucket, elencare i bucket disponibili ed eliminare il bucket appena creato. Potrai eseguire questo codice più tardi.
Nell' AWS Cloud9 IDE, crea un file con questo contenuto e salva il file con il nome`s3.go`.
```
package main
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
)
func main() {
if len(os.Args) < 3 {
fmt.Printf("Usage: go run s3.go \n" +
"Example: go run s3.go my-test-bucket us-east-2\n")
os.Exit(1)
}
sess := session.Must(session.NewSessionWithOptions(session.Options{
SharedConfigState: session.SharedConfigEnable,
}))
svc := s3.New(sess, &aws.Config{
Region: aws.String(os.Args[2]),
})
listMyBuckets(svc)
createMyBucket(svc, os.Args[1], os.Args[2])
listMyBuckets(svc)
deleteMyBucket(svc, os.Args[1])
listMyBuckets(svc)
}
// List all of your available buckets in this AWS Region.
func listMyBuckets(svc *s3.S3) {
result, err := svc.ListBuckets(nil)
if err != nil {
exitErrorf("Unable to list buckets, %v", err)
}
fmt.Println("My buckets now are:\n")
for _, b := range result.Buckets {
fmt.Printf(aws.StringValue(b.Name) + "\n")
}
fmt.Printf("\n")
}
// Create a bucket in this AWS Region.
func createMyBucket(svc *s3.S3, bucketName string, region string) {
fmt.Printf("\nCreating a new bucket named '" + bucketName + "'...\n\n")
_, err := svc.CreateBucket(&s3.CreateBucketInput{
Bucket: aws.String(bucketName),
CreateBucketConfiguration: &s3.CreateBucketConfiguration{
LocationConstraint: aws.String(region),
},
})
if err != nil {
exitErrorf("Unable to create bucket, %v", err)
}
// Wait until bucket is created before finishing
fmt.Printf("Waiting for bucket %q to be created...\n", bucketName)
err = svc.WaitUntilBucketExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// Delete the bucket you just created.
func deleteMyBucket(svc *s3.S3, bucketName string) {
fmt.Printf("\nDeleting the bucket named '" + bucketName + "'...\n\n")
_, err := svc.DeleteBucket(&s3.DeleteBucketInput{
Bucket: aws.String(bucketName),
})
if err != nil {
exitErrorf("Unable to delete bucket, %v", err)
}
// Wait until bucket is deleted before finishing
fmt.Printf("Waiting for bucket %q to be deleted...\n", bucketName)
err = svc.WaitUntilBucketNotExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// If there's an error, display it.
func exitErrorf(msg string, args ...interface{}) {
fmt.Fprintf(os.Stderr, msg+"\n", args...)
os.Exit(1)
}
```
## Passaggio 6: Esegui il codice AWS SDK
1. Nell' AWS Cloud9 IDE, nella barra dei menu, scegli **Esegui, Esegui** **configurazioni**, **Nuova configurazione di esecuzione**.
1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Go**.
1. In **Comando**`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `, digita, dove ` YOUR_BUCKET_NAME ` è il nome del bucket che desideri creare, quindi elimina, ed ` THE_AWS_REGION ` è l'ID della AWS regione in cui desideri creare il bucket. Ad esempio, per la regione Stati Uniti orientali (Ohio) utilizzare `us-east-2`. Per ulteriori informazioni IDs, consulta [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) nel. *Riferimenti generali di Amazon Web Services*
**Nota**
I nomi dei bucket Amazon S3 devono essere univoci per tutti gli account, AWS non solo per il tuo account. AWS
1. Seleziona il pulsante **Run (Esegui)** e confronta gli output.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Fase 7: pulire
Per evitare addebiti continui sul tuo AWS account dopo aver utilizzato questo esempio, devi eliminare l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# TypeScript tutorial per AWS Cloud9
Questo tutorial mostra come lavorare TypeScript in un ambiente di AWS Cloud9 sviluppo.
Seguire questo tutorial e creare questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prerequisiti](#sample-typescript-prereqs)
+ [Fase 1: installare gli strumenti necessari](#sample-typescript-install)
+ [Fase 2: aggiungere un codice](#sample-typescript-code)
+ [Fase 3: eseguire il codice](#sample-typescript-run)
+ [Passaggio 4: installa e configura l' AWS SDK per JavaScript in Node.js](#sample-typescript-sdk)
+ [Passaggio 5: aggiungere il codice SDK AWS](#sample-typescript-sdk-code)
+ [Passaggio 6: esegui il codice SDK AWS](#sample-typescript-sdk-run)
+ [Fase 7: pulire](#sample-typescript-clean-up)
## Prerequisiti
Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).
## Fase 1: installare gli strumenti necessari
In questo passaggio, si installa TypeScript utilizzando Node Package Manager (**`npm`**). Per installare ** `npm` **, puoi utilizzare Node Version Manager (** `nvm` **). Se non disponi di ** `nvm` **, è possibile installarlo in questa fase.
1. In una sessione di terminale nell' AWS Cloud9 IDE, verificate se TypeScript è già installato eseguendo il TypeScript compilatore da riga di comando con l'**`--version`**opzione. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale). In caso di successo, l'output contiene il numero di TypeScript versione. Se TypeScript è installato, vai avanti a[Fase 2: aggiungere un codice](#sample-typescript-code).
```
tsc --version
```
1. Conferma se ** `npm` ** è già installato eseguendo ** `npm` ** con l'opzione ** `--version` **. In caso di esito positivo, l'output contiene il numero di versione di ** `npm` **. Se **`npm`**è installato, vai avanti al passaggio 10 di questa procedura da utilizzare **`npm`**per l'installazione. TypeScript
```
npm --version
```
1. Esegui il comando ** `yum update` ** per (Amazon Linux) o ** `apt update` ** per (Ubuntu Server) per verificare che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug più recenti.
Per Amazon Linux:
```
sudo yum -y update
```
Per Ubuntu Server:
```
sudo apt update
```
1. Per l'installazione **`npm`**, inizia eseguendo il seguente comando per scaricare Node Version Manager (**`nvm`**). (**`nvm`**è un semplice script di shell Bash utile per installare e gestire le versioni di Node.js. Per ulteriori informazioni, consulta [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md) sul GitHub sito Web.)
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Per iniziare a utilizzare ** `nvm` **, chiudi la sessione del terminale e avviala nuovamente oppure trova il file `~/.bashrc` che contiene i comandi per scaricare ** `nvm` **.
```
. ~/.bashrc
```
1. Conferma che ** `nvm` ** è installato eseguendo ** `nvm` ** con l'opzione ** `--version` **.
```
nvm --version
```
1. Installa l'ultima versione 16 di Node.js eseguendo **`nvm`**. (**`npm`**è incluso in Node.js.)
```
nvm install v16
```
1. Conferma che Node.js è installato eseguendo la versione della riga di comando di Node.js con l'opzione ** `--version` **.
```
node --version
```
1. Conferma che ** `npm` ** è installato eseguendo ** `npm` ** con l'opzione ** `--version` **.
```
npm --version
```
1. Installa TypeScript eseguendo **`npm`**con l'**`-g`**opzione. Si installa TypeScript come pacchetto globale nell'ambiente.
```
npm install -g typescript
```
1. Conferma che TypeScript sia installato eseguendo il TypeScript compilatore a riga di comando con l'**`--version`**opzione.
```
tsc --version
```
## Fase 2: aggiungere un codice
1. Nell' AWS Cloud9 IDE, create un file denominato`hello.ts`. (Per creare un file, nella barra dei menu scegli **File**, **New File** (Nuovo file). Per salvare il file, scegli **File**,**Save** (Salva)).
1. In un terminale nell'IDE, dalla stessa directory del file `hello.ts`, esegui ** `npm` ** per installare la libreria `@types/node`.
```
npm install @types/node
```
Questa operazione aggiunge una cartella `node_modules/@types/node` nella stessa directory del file `hello.ts`. Questa nuova cartella contiene le definizioni dei tipi di Node.js che saranno TypeScript necessarie più avanti in questa procedura per le `console.log` `process.argv` proprietà che aggiungerete al `hello.ts` file.
1. Aggiungi il seguente codice al file `hello.ts`:
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
const sum: number = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## Fase 3: eseguire il codice
1. Nel terminale, dalla stessa directory del `hello.ts` file, esegui il TypeScript compilatore. Specifica il file `hello.ts` e le librerie aggiuntive da includere.
```
tsc hello.ts --lib es6
```
TypeScript utilizza il `hello.ts` file e un set di ECMAScript 6 (ES6) file di libreria per trasporre il TypeScript codice nel `hello.ts` file in JavaScript codice equivalente in un file denominato. `hello.js`
1. Nella finestra **Environment (Ambiente)** apri il file `hello.js`.
1. Nella barra dei menu, selezionare **Run (Esegui)**, **Run Configurations (Configurazioni esecuzione)**, **New Run Configuration (Nuova configurazione esecuzione)**.
1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Node.js**.
1. Per **Command (Comando)**, digitare `hello.js 5 9`. Nel codice, `5` rappresenta `process.argv[2]`, mentre `9` rappresenta `process.argv[3]`. (`process.argv[0]` rappresenta il nome del runtime (`node`) e `process.argv[1]` rappresenta il nome del file (`hello.js`).)
1. Seleziona **Run (Esegui)** ed esegui un confronto dell'output. Al termine, scegli **Stop (Arresta)**.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Output di Node.js dopo l'esecuzione del codice nell'IDE AWS Cloud9\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**Nota**
Invece di creare una nuova configurazione di esecuzione nell'IDE, puoi anche eseguire questo codice eseguendo il comando ** `node hello.js 5 9` ** dal terminale.
## Passaggio 4: installa e configura l' AWS SDK per JavaScript in Node.js
Puoi migliorare questo esempio per utilizzare l' AWS SDK di Node.js per JavaScript creare un bucket Amazon S3, elencare i bucket disponibili e quindi eliminare il bucket appena creato.
In questo passaggio, installi e configuri l' AWS SDK per Node.js. JavaScript L'SDK offre un modo pratico per interagire con AWS servizi come Amazon S3, dal JavaScript tuo codice. Dopo aver installato l' AWS SDK for JavaScript in Node.js, devi configurare la gestione delle credenziali nel tuo ambiente. L'SDK necessita di queste credenziali per interagire con i servizi. AWS
### Per installare l' AWS SDK for in Node.js JavaScript
In una sessione terminale nell' AWS Cloud9 IDE, dalla stessa directory del `hello.js` file da[Fase 3: eseguire il codice](#sample-typescript-run), **`npm`**esegui l'installazione dell' AWS SDK per Node.js JavaScript .
```
npm install aws-sdk
```
Questo comando aggiunge varie cartelle alla cartella `node_modules` da [Fase 3: eseguire il codice](#sample-typescript-run). Queste cartelle contengono il codice sorgente e le dipendenze per l' AWS SDK per JavaScript Node.js. *Per ulteriori informazioni, consulta [Installazione dell'SDK for JavaScript nella Guida per gli](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)AWS SDK per JavaScript sviluppatori.*
### Per configurare la gestione delle credenziali nell'ambiente
Ogni volta che si utilizza l' AWS SDK for JavaScript in Node.js per chiamare un AWS servizio, è necessario fornire un set di credenziali con la chiamata. Queste credenziali determinano se l' AWS SDK per JavaScript Node.js dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.
In questa fase si archiviano le credenziali all'interno dell'ambiente A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento.
Per ulteriori informazioni consulta [Impostazione delle credenziali su Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html) nella *Guida per gli sviluppatori di AWS SDK per JavaScript *.
## Passaggio 5: aggiungere il codice SDK AWS
In questa fase si aggiunge altro codice, questa volta per interagire con Amazon S3 e creare un bucket, elencare i bucket disponibili ed eliminare il bucket appena creato. Potrai eseguire questo codice più tardi.
1. Nell' AWS Cloud9 IDE, nella stessa directory del `hello.js` file nei passaggi precedenti, create un file denominato`s3.ts`.
1. Da un terminale dell' AWS Cloud9 IDE, nella stessa directory del `s3.ts` file, abilita il codice per chiamare le operazioni di Amazon S3 in modo asincrono eseguendolo **`npm`**due volte per installare la libreria asincrona e ancora per. TypeScript JavaScript
```
npm install @types/async # For TypeScript.
npm install async # For JavaScript.
```
1. Aggiungi il seguente codice al file `s3.ts`:
```
import * as async from 'async';
import * as AWS from 'aws-sdk';
if (process.argv.length < 4) {
console.log('Usage: node s3.js \n' +
'Example: node s3.js my-test-bucket us-east-2');
process.exit(1);
}
const AWS = require('aws-sdk'); // To set the AWS credentials and AWS Region.
const async = require('async'); // To call AWS operations asynchronously.
const s3: AWS.S3 = new AWS.S3({apiVersion: '2006-03-01'});
const bucket_name: string = process.argv[2];
const region: string = process.argv[3];
AWS.config.update({
region: region
});
const create_bucket_params: any = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region
}
};
const delete_bucket_params: any = {
Bucket: bucket_name
};
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback): void {
s3.listBuckets(function(err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (let i: number = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback): void {
console.log("\nCreating a bucket named '" + bucket_name + "'...\n");
s3.createBucket(create_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback): void {
console.log("\nDeleting the bucket named '" + bucket_name + "'...\n");
s3.deleteBucket(delete_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets
]);
```
## Passaggio 6: esegui il codice SDK AWS
1. Nel terminale, dalla stessa directory del `s3.ts` file, esegui il TypeScript compilatore. Specifica il file `s3.ts` e le librerie aggiuntive da includere.
```
tsc s3.ts --lib es6
```
TypeScript utilizza il `s3.ts` file, l' AWS SDK for JavaScript in Node.js, la libreria async e un set di ECMAScript 6 (ES6) file di libreria per trasporre il TypeScript codice nel file in codice equivalente JavaScript in un `s3.ts` file denominato. `s3.js`
1. Nella finestra **Environment (Ambiente)** apri il file `s3.js`.
1. Nella barra dei menu, selezionare **Run (Esegui)**, **Run Configurations (Configurazioni esecuzione)**, **New Run Configuration (Nuova configurazione esecuzione)**.
1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Node.js**.
1. In **Comando**, digitate`s3.js YOUR_BUCKET_NAME THE_AWS_REGION `, dove ` YOUR_BUCKET_NAME ` è il nome del bucket che desiderate creare e quindi eliminare, e ` THE_AWS_REGION ` indica l'ID della AWS regione in cui creare il bucket. Ad esempio, per la regione Stati Uniti orientali (Ohio) utilizzare `us-east-2`. Per ulteriori informazioni IDs, consulta [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) nel. *Riferimenti generali di Amazon Web Services*
**Nota**
I nomi dei bucket Amazon S3 devono essere univoci per tutti gli account, AWS non solo per il tuo account. AWS
1. Seleziona **Run (Esegui)** ed esegui un confronto dell'output. Al termine, scegli **Stop (Arresta)**.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Fase 7: pulire
Per evitare addebiti continui sul tuo AWS account dopo aver finito di utilizzare questo esempio, devi eliminare l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
# Tutorial Docker per AWS Cloud9
Questo tutorial mostra come connettere un ambiente di sviluppo AWS Cloud9 SSH a un contenitore Docker in esecuzione all'interno di un'istanza Amazon Linux in Amazon EC2. Ciò consente di utilizzare l' AWS Cloud9 IDE per lavorare con codice e file all'interno di un contenitore Docker ed eseguire comandi su quel contenitore. Per informazioni su Docker, consulta [Che cos'è Docker](https://www.docker.com/what-docker) sul sito Web Docker.
Seguire questo tutorial e creare questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Prerequisiti](#sample-docker-prereqs)
+ [Fase 1: installare ed eseguire Docker](#sample-docker-install)
+ [Fase 2: costruire l'immagine](#sample-docker-build)
+ [Fase 3: eseguire il container](#sample-docker-run)
+ [Fase 4: creare l'ambiente](#sample-docker-env)
+ [Fase 5: eseguire il codice](#sample-docker-code)
+ [Fase 6: pulizia](#sample-docker-clean-up)
## Prerequisiti
+ **È necessaria un'istanza Amazon EC2 che esegua Amazon Linux o Ubuntu Server.** Questo esempio presuppone che nel tuo account sia già presente un'istanza Amazon EC2 che esegue Amazon Linux o Ubuntu Server. AWS Per avviare un'istanza Amazon EC2, consulta [Avvio di macchine virtuali Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/). Nella pagina **Choose an Amazon Machine Image (AMI)** (Scegliere un'Amazon Machine Image (AMI)) della procedura guidata, scegli un'AMI il cui nome visualizzato inizi con **AMI Amazon Linux** o **Ubuntu Server**.
+ **Se l'istanza Amazon EC2 viene eseguita all'interno di un Amazon VPC, vi sono requisiti aggiuntivi.** Per informazioni, consulta [Impostazioni VPC per AWS Cloud9 ambienti di sviluppo](vpc-settings.md).
+ **L'istanza Amazon EC2 deve avere come minimo da 8 a 16 GB di spazio libero su disco.** In questo esempio vengono utilizzate immagini Docker di dimensioni superiori a 3 GB ed è possibile utilizzare ulteriori incrementi di almeno 3 GB di spazio su disco per creare immagini. Se tenti di eseguire questo esempio su un disco che dispone al massimo di 8 GB di spazio libero, è possibile che l'immagine Docker non venga creata o che il container Docker non venga eseguito. Per controllare lo spazio libero su disco dell'istanza, puoi eseguire un comando come ** `df -h` ** (per "informazioni sul file system del disco in formato leggibile") sull'istanza. Per aumentare la dimensione del disco di un'istanza esistente, consulta [Modifying a Volume](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html) nella *Amazon EC2* User Guide.
## Fase 1: installare ed eseguire Docker
In questa fase si controlla se Docker è installato sull'istanza Amazon EC2 e si installa Docker se non è già stato fatto. Dopo aver installato Docker, eseguilo sull'istanza.
1. Esegui la connessione all'istanza Amazon EC2 in esecuzione utilizzando un client SSH, ad esempio l'utilità ** `ssh` ** o PuTTY. A tale scopo, consulta "Fase 3: eseguire la connessione all'istanza" in [Avvio di macchine virtuali Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/).
1. Controlla se Docker è installato sull'istanza. Per farlo, esegui il comando ** `docker` ** sull'istanza con l'opzione ** `--version` **.
```
docker --version
```
Se Docker è installato, vengono visualizzati la versione e il numero build del Docker. In questo caso, passa alla fase 5 più avanti in questa procedura.
1. Installazione di Docker. Per farlo, esegui il comando ** `yum` ** o ** `apt` ** con l'operazione ** `install` **, specificando il pacchetto ** `docker` ** o ** `docker.io` ** da installare.
Per Amazon Linux:
```
sudo yum install -y docker
```
Per Ubuntu Server:
```
sudo apt install -y docker.io
```
1. Conferma che Docker è installato. Per farlo, esegui nuovamente il comando ** `docker --version` **. Vengono visualizzati la versione e il numero build del Docker.
1. Esegui il Docker. Per farlo, esegui il comando ** `service` ** con il servizio ** `docker` ** e l'operazione ** `start` **.
```
sudo service docker start
```
1. Conferma che il Docker è in esecuzione. Per farlo, esegui il comando ** `docker` ** con l'operazione ** `info` **.
```
sudo docker info
```
Se il Docker è in esecuzione, vengono visualizzate informazioni sul Docker.
## Fase 2: costruire l'immagine
In questa fase si utilizza un Dockerfile per creare un'immagine Docker sull'istanza. In questo esempio viene utilizzata un'immagine che include Node.js e un'applicazione server di chat di esempio.
1. Nell'istanza, crea il Dockerfile. Per farlo, con il client SSH ancora connesso all'istanza, nella directory `/tmp` sull'istanza, crea un file denominato `Dockerfile`. Ad esempio, esegui il comando ** `touch` ** come segue.
```
sudo touch /tmp/Dockerfile
```
1. Aggiungi i seguenti contenuti al file `Dockerfile`.
```
# Build a Docker image based on the Amazon Linux 2 Docker image.
FROM amazonlinux:2
# install common tools
RUN yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
RUN yum update -y
RUN yum install -y sudo bash curl wget git man-db nano vim bash-completion tmux gcc gcc-c++ make tar
# Enable the Docker container to communicate with AWS Cloud9 by
# installing SSH.
RUN yum install -y openssh-server
# Ensure that Node.js is installed.
RUN yum install -y nodejs
# Create user and enable root access
RUN useradd --uid 1000 --shell /bin/bash -m --home-dir /home/ubuntu ubuntu && \
sed -i 's/%wheel\s.*/%wheel ALL=NOPASSWD:ALL/' /etc/sudoers && \
usermod -a -G wheel ubuntu
# Add the AWS Cloud9 SSH public key to the Docker container.
# This assumes a file named authorized_keys containing the
# AWS Cloud9 SSH public key already exists in the same
# directory as the Dockerfile.
RUN mkdir -p /home/ubuntu/.ssh
ADD ./authorized_keys /home/ubuntu/.ssh/authorized_keys
RUN chown -R ubuntu /home/ubuntu/.ssh /home/ubuntu/.ssh/authorized_keys && \
chmod 700 /home/ubuntu/.ssh && \
chmod 600 /home/ubuntu/.ssh/authorized_keys
# Update the password to a random one for the user ubuntu.
RUN echo "ubuntu:$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)" | chpasswd
# pre-install Cloud9 dependencies
USER ubuntu
RUN curl https://d2j6vhu5uywtq3.cloudfront.net/static/c9-install.sh | bash
USER root
# Start SSH in the Docker container.
CMD ssh-keygen -A && /usr/sbin/sshd -D
```
Per aggiungere i contenuti precedenti al file `Dockerfile`, puoi utilizzare l'utilità ** `vi` ** sull'istanza come segue.
1. Usa il AWS Cloud9 per aprire e modificare il `/tmp/Dockerfile` file.
```
sudo vi /tmp/Dockerfile
```
1. Incolla il contenuto precedente nel file `Dockerfile`. In caso di dubbi su come eseguire questa operazione, vedi la documentazione del client SSH.
1. Passa alla modalità di comando. Per eseguire questa operazione, premere `Esc` (`-- INSERT --` scompare dalla parte inferiore della finestra).
1. Digita `:wq` (per scrivere nel file `/tmp/Dockerfile`, salvare il file e quindi uscire da ** `vi` **), quindi premi `Enter`.
**Nota**
Puoi accedere a un elenco aggiornato frequentemente di immagini Docker da AWS CodeBuild. Per ulteriori informazioni, consulta [le immagini Docker fornite CodeBuild nella Guida per](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html) l'*AWS CodeBuild utente*.
1. Nell'istanza, crea un file che contenga la chiave pubblica AWS Cloud9 SSH per il contenitore Docker da utilizzare. Per farlo, nella stessa directory del file `Dockerfile`, crea un file denominato `authorized_keys`, ad esempio, eseguendo il comando ** `touch` **.
```
sudo touch /tmp/authorized_keys
```
1. Aggiungi la chiave pubblica AWS Cloud9 SSH al file. `authorized_keys` Per ottenere la chiave pubblica AWS Cloud9 SSH, procedi come segue:
1. Apri la AWS Cloud9 console all'indirizzo [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).
1. Nella barra di AWS navigazione, nel selettore della AWS regione, scegli la AWS regione in cui desideri creare l'ambiente di AWS Cloud9 sviluppo più avanti in questo argomento.
1. Se viene visualizzata una pagina di benvenuto, per **Nuovo AWS Cloud9 ambiente**, scegli **Crea ambiente.** Altrimenti, selezionare **Create environment (Crea ambiente)**.
1. Nella pagina **Name environment** (Nomina ambiente), per **Name** (Nome), digita un nome per l'ambiente. (Qui il nome non è importante. Sceglierai un nome diverso in seguito).
1. Seleziona **Fase successiva**.
1. Per **Environment type (Tipo di ambiente)**, scegli **Connect and run in remote server (SSH) (Connetti ed esegui nel server remoto (SSH))**.
1. Espandi **View public SSH key (Visualizza chiave pubblica SSH)**.
1. Scegliere **Copy key to clipboard (Copia chiave negli appunti)**. (Questa opzione si trova tra **View public SSH key (Visualizza chiave pubblica SSH)** e **Advanced settings (Impostazioni avanzate)**).
1. Seleziona **Annulla**.
1. Incolla il contenuto degli Appunti nel file `authorized_keys`, quindi salva il file. Ad esempio, puoi utilizzare l'utilità ** `vi` **, come descritto in precedenza in questa fase.
1. Costruisci l'immagine eseguendo il comando ** `docker` ** con l'operazione ** `build` **, aggiungendo il tag `cloud9-image:latest` all'immagine e specificando il percorso del file `Dockerfile` da utilizzare.
```
sudo docker build -t cloud9-image:latest /tmp
```
In caso di esito positivo, le ultime due righe dell'output di compilazione visualizzano `Successfully built` e `Successfully tagged`.
Per confermare che l'immagine è stata creata dal Docker, esegui il comando ** `docker` ** con l'operazione `image ls`.
```
sudo docker image ls
```
In caso di esito positivo, l'output visualizza una voce in cui il campo `REPOSITORY` è impostato su `cloud9-image` e il campo `TAG` è impostato su `latest`.
1. Prendi nota dell'indirizzo IP pubblico dell'istanza Amazon EC2. Questo sarà necessario nella [Fase 4: creare l'ambiente](#sample-docker-env). In caso di dubbi sull'indirizzo IP pubblico dell'istanza, puoi eseguire il seguente comando sull'istanza per ottenerlo.
```
curl http://169.254.169.254/latest/meta-data/public-ipv4
```
## Fase 3: eseguire il container
In questa fase, esegui un container Docker sull'istanza. Questo container è basato sull'immagine creata nella fase precedente.
1. Per eseguire il container Docker, esegui il comando ** `docker` ** sull'istanza con l'operazione ** `run` ** e le seguenti opzioni.
```
sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
```
+ `-d` esegue il container in modalità scollegata, terminando ogni volta che il processo root utilizzato per eseguire il container (in questo esempio, il client SSH) termina.
+ `-it` esegue il container con uno pseudo TTY allocato e mantiene STDIN aperto, anche se il container non è collegato.
+ `--expose` rende la porta specificata (in questo esempio, porta `9090`) disponibile dal container.
+ `-p` rende la porta specificata disponibile internamente all'istanza Amazon EC2 sull'indirizzo IP e la porta specificati. In questo esempio, l'accesso alla porta `9090` sul container avviene internamente tramite la porta `22` sull'istanza Amazon EC2.
+ `--name` è un nome leggibile del container (in questo esempio `cloud9`).
+ `cloud9-image:latest` è il nome leggibile dell'immagine creata da utilizzare per eseguire il container.
Per confermare che Docker esegue correttamente il container, esegui il comando ** `docker` ** con l'operazione `container ls`.
```
sudo docker container ls
```
In caso di esito positivo, l'output visualizza una voce in cui il campo `IMAGE` è impostato su `cloud9-image:latest` e il campo `NAMES` è impostato su `cloud9`.
1. Accedi al container in esecuzione. Per farlo, esegui il comando ** `docker` ** con l'operazione ** `exec` ** e le seguenti opzioni.
```
sudo docker exec -it cloud9 bash
```
+ `-it` esegue il container con uno pseudo TTY allocato e mantiene STDIN aperto, anche se il container non è collegato.
+ `cloud9` è il nome leggibile del container in esecuzione.
+ `bash` avvia la shell standard nel container in esecuzione.
In caso di esito positivo, il prompt del terminale cambia per visualizzare il nome dell'utente collegato per il container e l'ID del container.
**Nota**
Se desideri disconnetterti dal container in esecuzione, esegui il comando ** `exit` **. Il prompt del terminale torna a visualizzare il nome dell'utente collegato per l'istanza e il DNS privato dell'istanza. Il container deve ancora essere in esecuzione.
1. Per la directory sul contenitore in esecuzione da cui desideri AWS Cloud9 iniziare dopo l'accesso, imposta le relative autorizzazioni di accesso su. **`rwxr-xr-x`** Ciò significa read-write-execute autorizzazioni per il proprietario, autorizzazioni di lettura-esecuzione per il gruppo e autorizzazioni di lettura-esecuzione per gli altri. Ad esempio, se il percorso della directory è `~`, puoi impostare queste autorizzazioni per la directory eseguendo il comando ** `chmod` ** nel container in esecuzione, come descritto di seguito.
```
sudo chmod u=rwx,g=rx,o=rx ~
```
1. Prendi nota del percorso alla directory sul container in esecuzione che contiene il binario Node.js, poiché sarà necessario nella [Fase 4: creare l'ambiente](#sample-docker-env). In caso di dubbi sul percorso, esegui il comando seguente sul container in esecuzione per ottenerlo.
```
which node
```
## Fase 4: creare l'ambiente
In questo passaggio, viene utilizzato AWS Cloud9 per creare un ambiente di sviluppo AWS Cloud9 SSH e collegarlo al contenitore Docker in esecuzione. Dopo aver AWS Cloud9 creato l'ambiente, visualizza l' AWS Cloud9 IDE in modo da poter iniziare a lavorare con i file e il codice nel contenitore.
Crei un ambiente di sviluppo AWS Cloud9 SSH con la AWS Cloud9 console. Non puoi creare un ambiente SSH utilizzando la CLI.
### Prerequisiti
+ Per prima cosa assicurati di aver completato la procedura indicata in [Configurazione AWS Cloud9](setting-up.md). Potrai così accedere alla console AWS Cloud9 e creare gli ambienti.
+ Identifica un'istanza di cloud computing esistente (ad esempio, un'istanza Amazon EC2 nella Account AWS tua) o il tuo server che AWS Cloud9 desideri connettere all'ambiente.
+ Verificare che l'istanza esistente o i server soddisfino tutti i [Requisiti host SSH](ssh-settings.md#ssh-settings-requirements). Ciò include avere già installato versioni specifiche di Python, Node.js e altri componenti; l'impostazione di autorizzazioni specifiche nella directory dalla quale AWS Cloud9 deve effettuare l'avvio dopo il login e la configurazione di qualsiasi Amazon Virtual Private Cloud associato.
### Creazione dell'ambiente SSH
1. Assicurati di aver soddisfatto i prerequisiti precedenti.
1. Se non l'hai già fatto, connettiti all'istanza esistente o al server utilizzando un client SSH. Avrai così la certezza di poter aggiungere il valore della chiave SSH pubblica necessaria all'istanza o al server. Questa parte è descritta più avanti in questa procedura.
**Nota**
Per connetterti a un'istanza di Cloud AWS calcolo esistente, consulta una o più delle seguenti risorse:
Per Amazon EC2, consulta [Connect to Your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) nella *Amazon EC2* User Guide.
Per Amazon Lightsail, consulta [Connessione all'istanza Linux/Lightsail basata su Unix](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server) nella *Documentazione di Amazon Lightsail*.
*Per AWS Elastic Beanstalk, consulta [Elenco e connessione alle istanze del server](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.ec2connect.html) nella Guida per gli AWS Elastic Beanstalk sviluppatori.*
Per AWS OpsWorks, consulta [Uso di SSH per accedere a un'istanza Linux nella Guida](https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-ssh.html) per l'*AWS OpsWorks utente*.
Per altre informazioni Servizi AWS, consulta la documentazione relativa a quel servizio specifico.
Per connetterti al tuo server, utilizza SSH. SSH è già installato sui sistemi operativi macOS e Linux. Per connettersi al server utilizzando SSH su Windows, è necessario installare [PuTTY](https://www.putty.org/).
1. Accedi alla AWS Cloud9 console, all'indirizzo [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).
1. Dopo aver effettuato l'accesso alla AWS Cloud9 console, nella barra di navigazione in alto scegli un ambiente in cui Regione AWS creare l'ambiente. Per un elenco di quelli disponibili Regioni AWS, [AWS Cloud9](https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region)consulta *Riferimenti generali di AWS*.
![\[Selettore di regione nella console AWS Cloud9\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/consolas_region_new_UX.png)
1. Se è la prima volta che crei un ambiente di sviluppo, viene visualizzata una pagina di benvenuto. Nel pannello **Nuovo AWS Cloud9 ambiente**, scegli **Crea ambiente.**
Se in precedenza hai creato ambienti di sviluppo, puoi anche espandere il riquadro a sinistra della schermata. Scegli **Your environments** (I tuoi ambienti), quindi **Create environment** (Crea ambiente).
Nella pagina di **benvenuto**:
![\[Scegli il pulsante Create environment (Crea ambiente) se viene mostrata la pagina di benvenuto\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)
Oppure nella pagina **Your environments** (Ambienti):
![\[Scegli il pulsante Create environment (Crea ambiente) se non viene mostrata la pagina di benvenuto\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/console_create_env_new_UX.png)
1. Nella pagina **Create environment** (Crea ambiente), inserisci un nome per l'ambiente.
1. In **Description** (Descrizione), inserire qualcosa nell'ambiente. Per questo tutorial, utilizza `This environment is for the AWS Cloud9 tutorial.`
1. Per **Environment type** (Tipo ambiente), scegli **Existing Compute** (Elaborazione esistente) tra le opzioni seguenti:
+ **Nuova istanza EC2**: avvia un'istanza Amazon EC2 a AWS Cloud9 cui è possibile connettersi direttamente tramite SSH.
+ **Elaborazione esistente**: avvia un'istanza Amazon EC2 che non richiede porte in ingresso aperte. AWS Cloud9 si connette all'istanza tramite. [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html)
+ Se selezioni l'opzione **Existing compute** (Elaborazione esistente), vengono creati un ruolo di servizio e un profilo dell'istanza IAM per permettere a Systems Manager di interagire con l'istanza EC2 per tuo conto. Puoi visualizzare i nomi di entrambi nella sezione **Service role and instance profile for Systems Manager access** (Profilo dell'stanza e ruolo di servizio per l'accesso a Systems Manager) più in basso nell'interfaccia. Per ulteriori informazioni, consulta [Accesso alle istanze EC2 senza ingresso con AWS Systems Manager](ec2-ssm.md).
**avvertimento**
La creazione di un'istanza EC2 per il tuo ambiente potrebbe comportare possibili addebiti Account AWS per Amazon EC2. L'utilizzo di Systems Manager per gestire le connessioni all'istanza EC2 non comporta costi aggiuntivi.
**avvertimento**
AWS Cloud9 utilizza la chiave pubblica SSH per connettersi in modo sicuro al server. Per stabilire una connessione sicura, aggiungi la nostra chiave pubblica al tuo file `~/.ssh/authorized_keys` e fornisci le tue credenziali di accesso nei passaggi seguenti. Scegli **Copy key to clipboard** (Copia chiave negli appunti) per copiare la chiave SSH o **View public SSH key** (Visualizza chiave SSH pubblica) per visualizzarla.
1. Nel pannello **Existing compute** (Elaborazione esistente), in **User** (Utente) inserisci il nome di accesso che hai utilizzato per connetterti all'istanza o al server in precedenza in questa procedura. Ad esempio, per un'istanza di calcolo Cloud AWS , potrebbe essere `ec2-user`, `ubuntu` o `root`.
**Nota**
È consigliabile che il nome di accesso sia associato a privilegi amministrativi o a un utente amministratore sull'istanza o sul server. Più nello specifico, è consigliabile che questo nome di accesso sia il proprietario dell'installazione Node.js sull'istanza o sul server. Per verificare, esegui dal terminale dell'istanza o del server il comando ** `ls -l $(which node)` ** (o ** `ls -l $(nvm which node)` ** se utilizzi `nvm`). Questo comando mostra il nome del proprietario dell'installazione Node.js. Mostra anche le autorizzazioni, il nome del gruppo e il percorso dell'installazione.
1. Per **Host**, immetti l'indirizzo IP pubblico (preferito) o il nome host dell'istanza o del server.
1. In **Port**, inserisci la porta che desideri utilizzare AWS Cloud9 per provare a connetterti all'istanza o al server. In alternativa, puoi lasciare indicata la porta predefinita.
1. Scegli **Additional details - optional** (Dettagli aggiuntivi: facoltativo) per visualizzare il percorso dell'ambiente, il percorso per il binario node.js e le informazioni sul jump host SSH.
1. Per **Environment path**, inserisci il percorso della directory sull'istanza o sul server da cui AWS Cloud9 vuoi iniziare. Questo lo hai identificato in precedenza nei prerequisiti di questa procedura. Se lasci questa opzione vuota, AWS Cloud9 utilizza la directory da cui solitamente inizia l'istanza o il server dopo il login. In genere si tratta di una directory home o predefinita.
1. In **Path to Node.js binary path** Percorso per binario Node.js), immetti le informazioni sul percorso per specificare il percorso del binario Node.js sull'istanza o sul server. Per ottenere il percorso, puoi eseguire il comando **`which node`** (o ** `nvm which node` ** se utilizzi `nvm`) sull'istanza o sul server. Ad esempio, il percorso potrebbe essere `/usr/bin/node`. Se lasci vuota la casella, quando tenta di connettersi, AWS Cloud9 prova a indovinare dove si trova il file binario Node.js.
1. Per **SSH jump host** (Jum host SSH), immetti le informazioni sul jump host utilizzato dall'istanza o dal server. Utilizza il formato `USER_NAME@HOSTNAME:PORT_NUMBER` (ad esempio, `ec2-user@:ip-192-0-2-0:22`).
Il jump host deve soddisfare i seguenti requisiti:
+ Deve essere raggiungibile tramite Internet pubblico utilizzando SSH.
+ Deve consentire l'accesso in entrata tramite un indirizzo IP sulla porta specificata.
+ Il valore della chiave SSH pubblica copiato nel file `~/.ssh/authorized_keys` sull'istanza esistente o sul server deve essere copiato anche nel file `~/.ssh/authorized_keys` sul jump host.
+ Netcat deve essere installato.
1. Aggiungi fino a 50 tag fornendo una **chiave** e un **valore** per ogni tag. Per farlo, seleziona **Add new tag** (Aggiungi nuovo tag). I tag vengono allegati all' AWS Cloud9 ambiente come tag di risorse e vengono propagati alle seguenti risorse sottostanti: lo CloudFormation stack, l'istanza Amazon EC2 e i gruppi di sicurezza Amazon EC2. Per ulteriori informazioni sui tag, consulta [Control Access Using AWS Resource Tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) nella *[IAM User Guide e le [informazioni avanzate](tags.md) sui tag in questa guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/)*.
**avvertimento**
Se aggiorni questi tag dopo averli creati, le modifiche non vengono propagate alle risorse sottostanti. Per ulteriori informazioni, consulta [Propagazione degli aggiornamenti dei tag alle risorse sottostanti](tags.md#tags-propagate) nelle informazioni avanzate sui [tag](tags.md).
1. Scegli **Create** (Crea) per creare il tuo ambiente; verrai quindi reindirizzato alla home page. Quando l'account viene creato correttamente, nella parte superiore della AWS Cloud9 console viene visualizzata una barra flash verde. Puoi selezionare il nuovo ambiente e scegliere **Open in Cloud9** (Apri in Cloud9) per avviare l'IDE.
![\[AWS Cloud9 Selettore IDE nella console AWS Cloud9\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/cloud9-ide-open.png)
Se l'account non viene creato correttamente, viene visualizzata una barra flash rossa nella parte superiore della console AWS Cloud9 . La creazione dell'account potrebbe non riuscire a causa di un problema con il browser Web, le autorizzazioni di AWS accesso, l'istanza o la rete associata. Per informazioni sulle possibili soluzioni ai problemi di creazione dell'account, consulta la [sezione Risoluzione dei problemi di AWS Cloud9 .](troubleshooting.md#troubleshooting-env-loading)
**Nota**
Se il tuo ambiente utilizza un proxy per accedere a Internet, devi fornire i dettagli del proxy AWS Cloud9 in modo che possa installare le dipendenze. Per ulteriori informazioni, consulta [Impossibile installare le dipendenze](troubleshooting.md#proxy-failed-dependencies).
## Fase 5: eseguire il codice
In questo passaggio, si utilizza l' AWS Cloud9 IDE per eseguire un'applicazione di esempio all'interno del contenitore Docker in esecuzione.
1. Con l' AWS Cloud9 IDE visualizzato per il contenitore in esecuzione, avvia il server di chat di esempio. Per farlo, nella finestra **Environment (Ambiente)**, fai clic con il pulsante destro del mouse sul file `workspace/server.js` di esempio e scegli **Run (Esegui)**.
1. Visualizza l'anteprima dell'applicazione di esempio. Per farlo, nella finestra **Environment (Ambiente)**, apri il file `workspace/client/index.html`. Quindi, nella barra dei menu, scegli **Tools, Preview, Preview Running Application (Strumenti, Anteprima, Anteprima applicazione in esecuzione)**.
1. Nella scheda di anteprima dell'applicazione, per **Your Name (Nome)**, digita il tuo nome. In **Message (Messaggio)**, digita un messaggio. Quindi, scegli **Send (Invia)**. Il nome e il messaggio vengono aggiunti dal server di chat all'elenco.
## Fase 6: pulizia
In questo passaggio, elimini l'ambiente AWS Cloud9 e rimuovi i file di supporto Docker dall'istanza Amazon EC2. Inoltre, per evitare addebiti continui AWS sul tuo account dopo aver finito di utilizzare questo esempio, devi chiudere l'istanza Amazon EC2 su cui è in esecuzione Docker.
### Fase 6.1: eliminare l'ambiente
Per eliminare l'ambiente, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).
### Passaggio 6.2: rimuovere i file di AWS Cloud9 supporto dal contenitore
Dopo aver eliminato l'ambiente, alcuni file di AWS Cloud9 supporto rimangono ancora nel contenitore. Se desideri continuare a utilizzare il contenitore ma non hai più bisogno di questi file di supporto, elimina la `.c9` cartella dalla directory sul contenitore da cui hai specificato AWS Cloud9 per iniziare dopo l'accesso. Ad esempio, se la directory è `~`, esegui il comando ** `rm` ** con l'opzione ** `-r` ** come descritto di seguito.
```
sudo rm -r ~/.c9
```
### Fase 6.3: rimuovere i file di supporto Docker dall'istanza
Se non desideri più mantenere il container Docker, l'immagine Docker e Docker sull'istanza Amazon EC2, ma desideri mantenere l'istanza, puoi rimuovere questi file di supporto Docker come segue.
1. Rimuovi il container Docker dall'istanza. Per farlo, esegui il comando ** `docker` ** sull'istanza con le operazioni di interruzione ** `stop` ** e ** `rm` ** e il nome del container leggibile.
```
sudo docker stop cloud9
sudo docker rm cloud9
```
1. Rimuovi l'immagine Docker dall'istanza. Per farlo, esegui il comando ** `docker` ** sull'istanza con l'operazione ** `image rm` ** e il tag dell'immagine.
```
sudo docker image rm cloud9-image:latest
```
1. Rimuovi eventuali file di supporto Docker aggiuntivi che potrebbero ancora esistere. Per farlo, esegui il comando ** `docker` ** sull'istanza con l'operazione ** `system prune` **.
```
sudo docker system prune -a
```
1. Disinstalla Docker. Per farlo, esegui il comando ** `yum` ** sull'istanza con l'operazione ** `remove` **, specificando il pacchetto ** `docker` ** da disinstallare.
Per Amazon Linux:
```
sudo yum -y remove docker
```
Per Ubuntu Server:
```
sudo apt -y remove docker
```
Puoi anche rimuovere i file `Dockerfile` e `authorized_keys` creati in precedenza. Ad esempio, esegui il comando ** `rm` ** sull'istanza.
```
sudo rm /tmp/Dockerfile
sudo rm /tmp/authorized_keys
```
### Fase 6.4: terminare l'istanza
Per terminare l'istanza Amazon EC2, [consulta Terminate Your](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) Instance nella Amazon *EC2* User Guide.
## Tutorial correlati
+ [Guida introduttiva alla AWS RoboMaker](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html) Guida per gli *AWS RoboMaker sviluppatori*. Questo tutorial serve AWS Cloud9 a modificare, creare e raggruppare un'applicazione robotica di esempio.