AWS Cloud9 não está mais disponível para novos clientes. Os clientes atuais do AWS Cloud9 podem continuar usando o serviço normalmente. [Saiba mais](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Tutoriais para AWS Cloud9
Você é novo em AWS Cloud9? Faça um tour pelo IDE em [Conceitos básicos: tutoriais básicos](tutorials-basic.md).
Experimente esses tutoriais e exemplos de código para aumentar seu conhecimento e confiança usando várias linguagens AWS Cloud9 de programação e AWS serviços.
**Topics**
+ [AWS CLI e tutorial aws-shell](sample-aws-cli.md)
+ [AWS CodeCommit tutorial](sample-codecommit.md)
+ [Tutorial do Amazon DynamoDB](sample-dynamodb.md)
+ [AWS CDK tutorial](sample-cdk.md)
+ [Tutorial do LAMP](sample-lamp.md)
+ [WordPress tutorial](sample-wordpress.md)
+ [Tutorial de Java](sample-java.md)
+ [Tutorial de C\$1\$1](sample-cplusplus.md)
+ [Tutorial do Python](sample-python.md)
+ [Tutorial do .NET](sample-dotnetcore.md)
+ [Tutorial Node.js](sample-nodejs.md)
+ [Tutorial do PHP](sample-php.md)
+ [Ruby](tutorial-ruby.md)
+ [Tutorial do Go](sample-go.md)
+ [TypeScript tutorial](sample-typescript.md)
+ [Tutorial do Docker](sample-docker.md)
+ [Tutoriais relacionados](#samples-additonal)
# AWS CLI e tutorial aws-shell para AWS Cloud9
O tutorial a seguir permite que você configure o AWS Command Line Interface (AWS CLI), o aws-shell ou ambos em um ambiente de AWS Cloud9 desenvolvimento. O AWS CLI e o aws-shell são ferramentas unificadas que fornecem uma interface consistente para interagir com todas as partes do. AWS Você pode usar o AWS CLI em vez do Console de gerenciamento da AWS para executar rapidamente comandos com os quais interagir AWS, e alguns desses comandos podem ser executados com o AWS CLI ou, alternativamente, usando AWS CloudShell.
Para obter mais informações sobre o AWS CLI, consulte o [Guia AWS Command Line Interface do usuário](https://docs.aws.amazon.com/cli/latest/userguide/). Para o aws-shell, consulte os recursos a seguir:
+ [aws-shell](https://github.com/awslabs/aws-shell) no site GitHub
+ [aws-shell](https://pypi.python.org/pypi/aws-shell) no site do pip
Para obter uma lista de comandos que você pode executar com o AWS CLI para interagir AWS, consulte a [Referência de AWS CLI Comandos](https://docs.aws.amazon.com/cli/latest/reference/). Você pode usar os mesmos comandos com AWS CloudShell, exceto que você inicia comandos sem o `aws` prefixo.
A criação dessa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Pré-requisitos](#sample-aws-cli-prereqs)
+ [Etapa 1: instalar o AWS CLI, o aws-shell ou ambos em seu ambiente](#sample-aws-cli-install)
+ [Etapa 2: Configurar o gerenciamento de credenciais no ambiente](#sample-aws-cli-creds)
+ [Etapa 3: Execute comandos básicos com o AWS CLI ou o aws-shell em seu ambiente](#sample-aws-cli-run)
+ [Etapa 4: Limpar](#sample-aws-cli-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: instalar o AWS CLI, o aws-shell ou ambos em seu ambiente
Nesta etapa, você usa o AWS Cloud9 IDE para instalar o AWS CLI, o aws-shell ou ambos em seu ambiente para poder executar comandos com os quais interagir. AWS
Se você estiver usando um ambiente de desenvolvimento AWS Cloud9 EC2 e quiser usar apenas o. AWS CLI, você pode pular para. [Etapa 3: Execute comandos básicos com o AWS CLI ou o aws-shell em seu ambiente](#sample-aws-cli-run) Isso ocorre porque o já AWS CLI está instalado em um ambiente EC2 e um conjunto de credenciais de AWS acesso já está configurado no ambiente. Para obter mais informações, consulte [AWS credenciais temporárias gerenciadas](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Se você não estiver usando um ambiente EC2, faça o seguinte para instalar a AWS CLI:
1. Com seu ambiente aberto, no IDE, verifique se o já AWS CLI está instalado. No terminal, execute o comando ** `aws --version` **. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.) Se o AWS CLI estiver instalado, o número da versão será exibido, com informações como os números da versão do Python e o número da versão do sistema operacional da sua instância do Amazon EC2 ou do seu próprio servidor. Se o AWS CLI estiver instalado, vá para[Etapa 2: Configurar o gerenciamento de credenciais no ambiente](#sample-aws-cli-creds).
1. Para instalar o AWS CLI, consulte [Instalando o AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) no *Guia AWS Command Line Interface do Usuário*. Por exemplo, para um ambiente EC2 executando o Amazon Linux, execute estes três comandos, um de cada vez, no terminal para instalar a 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.
```
Por exemplo, para um ambiente EC2 que executa o Ubuntu Server, execute estes três comandos, um de cada vez, no terminal para instalar a 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.
```
Para instalar o aws-shell, faça o seguinte:
1. Com o ambiente aberto, no IDE, verifique se o aws-shell já está instalado. No terminal, execute o comando ** `aws-shell` **. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.) Se o aws-shell estiver instalado, a solicitação `aws>` é exibida. Se o aws-shell estiver instalado, avance para [Etapa 2: Configurar o gerenciamento de credenciais no ambiente](#sample-aws-cli-creds).
1. Para instalar o aws-shell, use o pip. Para usar o pip, é necessário ter o Python instalado.
Para verificar se o Python já está instalado (e para instalá-lo, se necessário), siga as instruções em [Etapa 1: Instalar o Python](sample-python.md#sample-python-install) no *Python Sample* (Exemplo do Python) e retorne a este tópico.
Para verificar se o pip já está instalado, no terminal, execute o comando ** `pip --version` **. Se o pip estiver instalado, o número da versão é exibido. Se o pip não estiver instalado, instale-o executando estes três comandos, um de cada vez, no terminal.
```
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. Para usar o pip para instalar o aws-shell, execute o comando a seguir.
```
sudo pip install aws-shell
```
## Etapa 2: Configurar o gerenciamento de credenciais no ambiente
Cada vez que você usa o AWS CLI ou o aws-shell para chamar um AWS serviço, você deve fornecer um conjunto de credenciais com a chamada. Essas credenciais determinam se o aws-shell AWS CLI ou o aws-shell tem as permissões apropriadas para fazer essa chamada. Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.
Se você estiver usando um ambiente de desenvolvimento AWS Cloud9 EC2, pode pular para. [Etapa 3: Execute comandos básicos com o AWS CLI ou o aws-shell em seu ambiente](#sample-aws-cli-run) Isso ocorre porque as credenciais já estão configuradas em um ambiente EC2. Para obter mais informações, consulte [AWS credenciais temporárias gerenciadas](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Se você não estiver usando um ambiente EC2, será necessário armazenar manualmente as credenciais dentro do ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
## Etapa 3: Execute comandos básicos com o AWS CLI ou o aws-shell em seu ambiente
Nesta etapa, você usa o AWS CLI ou o aws-shell em seu ambiente para criar um bucket no Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket.
1. Se deseja usar o aws-shell mas ainda não o iniciou, inicie o aws-shell executando o comando `aws-shell`. A solicitação `aws>` é exibida.
1. Crie um bucket. Execute o **`aws s3 mb`**comando com o **`s3 mb`**comando AWS CLI ou com o aws-shell, fornecendo o nome do bucket a ser criado. Neste exemplo, usamos um bucket chamado`cloud9-123456789012-bucket`, onde `123456789012` está o ID AWS da sua conta. Se usar um nome diferente, substitua-o ao longo desta etapa.
```
aws s3 mb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 mb s3://cloud9-123456789012-bucket # For the aws-shell.
```
**nota**
Os nomes dos buckets devem ser exclusivos em todas as contas AWS, não apenas AWS em sua conta. O nome de bucket sugerido anteriormente pode ajudá-lo a criar um nome de bucket único. Se receber uma mensagem que contém o erro `BucketAlreadyExists`, é necessário executar o comando novamente com um nome de bucket diferente.
1. Liste os buckets disponíveis. Execute o **`aws s3 ls`**comando com o AWS CLI ou o **`s3 ls`**comando com o aws-shell. Uma lista dos buckets disponíveis será exibida.
1. Exclua o bucket. Execute o **`aws s3 rb`**comando com o AWS CLI ou o **`s3 rb`**comando com o aws-shell, fornecendo o nome do bucket a ser excluído.
```
aws s3 rb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 rb s3://cloud9-123456789012-bucket # For the aws-shell.
```
Para confirmar se o bucket foi excluído, execute o **`aws s3 ls`**comando novamente com o AWS CLI ou o **`s3 ls`**comando novamente com o aws-shell. O nome do bucket que foi excluído não deve mais aparecer na lista.
**nota**
Não é necessário excluir o bucket se quiser continuar a usá-lo. Para obter mais informações, consulte [Adicionar um objeto a um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) no *Guia do Amazon Simple Storage Service*. Consulte também [s3 commands](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html.html) (Comandos do s3) na *Referência de comandos da AWS CLI *. (Lembre-se de que, se você não excluir o bucket, isso poderá resultar em cobranças contínuas em sua AWS conta.)
Para continuar experimentando com o AWS CLI, consulte [Trabalhando com a Amazon Web Services](https://docs.aws.amazon.com/cli/latest/userguide/chap-working-with-services.html) no *Guia do AWS Command Line Interface Usuário* e na [Referência de AWS CLI Comandos](https://docs.aws.amazon.com/cli/latest/reference/). Para continuar a testar o aws-shell, consulte a [AWS CLI Command Reference](https://docs.aws.amazon.com/cli/latest/reference/) (Referência de comandos da CLI da AWS), observando que você deve iniciar os comandos com o prefixo `aws`.
## Etapa 4: Limpar
Se estiver usando o aws-shell, você pode parar de usá-lo executando o comando ** `.exit` ** ou ** `.quit` **.
Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# AWS CodeCommit tutorial para AWS Cloud9
Você pode usar o AWS CodeCommit tutorial para configurar um ambiente de AWS Cloud9 desenvolvimento para interagir com um repositório de código remoto no CodeCommit. CodeCommit é um serviço de controle de código-fonte que você pode usar para armazenar e gerenciar Git repositórios de forma privada no. Nuvem AWS Para obter mais informações sobre CodeCommit, consulte o [Guia AWS CodeCommit do usuário](https://docs.aws.amazon.com/codecommit/latest/userguide/).
Seguir este tutorial e criar essa amostra pode resultar em cobranças para você Conta da AWS. Isso inclui possíveis cobranças por serviços como Amazon EC2 e. CodeCommit Para obter mais informações, consulte [Definição de preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Definição de preço do AWS CodeCommit](https://aws.amazon.com/codecommit/pricing/).
+ [Pré-requisitos](#sample-codecommit-prereqs)
+ [Etapa 1: Configurar o grupo do IAM com as permissões de acesso necessárias](#sample-codecommit-permissions)
+ [Etapa 2: criar um repositório no AWS CodeCommit](#sample-codecommit-create-repo)
+ [Etapa 3: Conectar o ambiente ao repositório remoto](#sample-codecommit-connect-repo)
+ [Etapa 4: Clonar o repositório remoto no ambiente](#sample-codecommit-clone-repo)
+ [Etapa 5: Adicionar arquivos ao repositório](#sample-codecommit-add-files)
+ [Etapa 6: Limpar](#sample-codecommit-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Configurar o grupo do IAM com as permissões de acesso necessárias
Suponha que suas AWS credenciais estejam associadas a um usuário administrador em seu Conta da AWS e você queira usar esse usuário para trabalhar com. CodeCommit Em seguida, vá para a [Etapa 2: Criar um repositório](#sample-codecommit-create-repo) no. AWS CodeCommit
Conclua essa etapa usando o [Console de gerenciamento da AWS](#sample-codecommit-permissions-console) ou a [interface da linha de comando da AWS (AWS CLI)](#sample-codecommit-permissions-cli).
### Configurar o grupo do IAM com as permissões de acesso necessárias usando o console
1. Faça login no Console de gerenciamento da AWS, se você ainda não estiver conectado.
Para esta etapa, recomendamos que faça login usando credenciais de um usuário administrador em sua Conta da AWS. Se isso não for possível, fale com o administrador de sua Conta da AWS .
1. Abra o console do IAM. Para fazer isso, na barra de navegação do console, selecione **Serviços**. Depois, selecione **IAM**.
1. Selecione **Grupos**.
1. Selecione o nome do grupo.
1. Na guia **Permssões**, em **Políticas gerenciadas**, selecione **Anexar política**.
1. Na lista de nomes de políticas, selecione uma das seguintes caixas:
+ Selecione **AWSCodeCommitPowerUser**para acessar todas as funcionalidades CodeCommit e recursos relacionados ao repositório. No entanto, isso não permite que você exclua CodeCommit repositórios nem crie ou exclua recursos relacionados ao repositório em outros, Serviços da AWS como o Amazon Events. CloudWatch
+ Selecione **AWSCodeCommitFullAccess**para ter controle total sobre CodeCommit repositórios e recursos relacionados no Conta da AWS. Isso inclui a capacidade de excluir repositórios.
Se nenhum desses nomes de política for encontrado na lista, insira os nomes das políticas na caixa **Filtrar** para exibi-las.
1. Escolha **Attach Policy**.
Para ver a lista de permissões de acesso que essas políticas AWS gerenciadas concedem a um grupo, consulte [Políticas AWS gerenciadas (predefinidas) AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) no *Guia do AWS CodeCommit usuário*.
Vá para a [Etapa 2: Criar um repositório](#sample-codecommit-create-repo) no. AWS CodeCommit
### Configure seu grupo do IAM com as permissões de acesso necessárias usando o AWS CLI
Execute o `attach-group-policy` comando IAM, especificando o nome do grupo e o Amazon Resource Name (ARN) da política gerenciada que descreve AWS as permissões de acesso necessárias. A sintaxe é a seguinte.
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
No comando anterior, substitua `MyGroup` pelo nome do grupo. `POLICY_ARN`Substitua pelo ARN da política AWS gerenciada:
+ `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser`para ter acesso a todas as funcionalidades CodeCommit e recursos relacionados ao repositório. No entanto, ele não permite que você exclua CodeCommit repositórios nem crie ou exclua recursos relacionados ao repositório em outros, Serviços da AWS como o Amazon Events. CloudWatch
+ `arn:aws:iam::aws:policy/AWSCodeCommitFullAccess`para controle total sobre CodeCommit repositórios e recursos relacionados no Conta da AWS. Isso inclui a capacidade de excluir repositórios.
Para ver a lista de permissões de acesso que essas políticas AWS gerenciadas concedem a um grupo, consulte [Políticas AWS gerenciadas (predefinidas) AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) no *Guia do AWS CodeCommit usuário*.
## Etapa 2: criar um repositório no CodeCommit
Nesta etapa, você cria um repositório de código remoto CodeCommit usando o CodeCommit console.
Se você já tiver um CodeCommit repositório, vá para a [Etapa 3: Conecte seu ambiente ao repositório remoto](#sample-codecommit-connect-repo).
Conclua essa etapa usando o [Console de gerenciamento da AWS](#sample-codecommit-create-repo-console) ou a [interface da linha de comando da AWS (AWS CLI)](#sample-codecommit-create-repo-cli).
### Crie um repositório CodeCommit usando o console
1. Suponha que você esteja conectado ao Console de gerenciamento da AWS como usuário administrador da etapa anterior e não queira usar o usuário administrador para criar o repositório. Em seguida, saia do Console de gerenciamento da AWS.
1. Abra o CodeCommit console, em [https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit).
1. Na barra de navegação do console, use o seletor de região para selecionar a Região da AWS onde deseja criar o repositório. Por exemplo, **US East (Ohio)** [Leste dos EUA (Ohio)].
1. Se uma página de boas-vindas for exibida, escolha **Get started**. Caso contrário, selecione **Criar repositório**.
1. Na página **Criar repositório**, em **Nome do repositório**, insira um nome para o novo repositório (por exemplo, `MyDemoCloud9Repo`). Se escolher um nome diferente, substitua-o ao longo desse exemplo.
1. (Opcional) Em **Descrição**, insira algo sobre o repositório. Por exemplo, insira: `This is a demonstration repository for the AWS Cloud9 sample.`
1. Escolha **Criar repositório**. Um painel **Conectar ao repositório** é exibido. Selecione **Fechar**, uma vez que se conectará ao repositório de forma diferente mais adiante nesse tópico.
Avance até a [Etapa 3: Conectar o ambiente ao repositório remoto](#sample-codecommit-connect-repo).
### Crie um repositório CodeCommit usando o AWS CLI
Execute o comando AWS CodeCommit `create-repository`. Especifique o nome do repositório, uma descrição opcional e o local Região da AWS para criar o repositório.
```
aws codecommit create-repository --repository-name MyDemoCloud9Repo --repository-description "This is a demonstration repository for the AWS Cloud9 sample." --region us-east-2
```
No comando anterior, substitua `us-east-2` pelo ID da Região da AWS onde o repositório será criado. Para ver uma lista das regiões compatíveis, consulte [AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region) no *Referência geral da Amazon Web Services*.
Se decidiu usar um nome de repositório diferente, substitua-o ao longo desse exemplo.
## Etapa 3: Conectar o ambiente ao repositório remoto
Nesta etapa, você usa o AWS Cloud9 IDE para se conectar ao CodeCommit repositório que você criou ou identificou na etapa anterior.
**nota**
Se preferir trabalhar com o Git por meio de uma interface visual, você poderá clonar o repositório remoto. Depois, você poderá adicionar arquivos usando o recurso [Painel do Git](source-control-gitpanel.md) que está disponível no IDE.
Conclua um dos conjuntos de procedimentos a seguir de acordo com o tipo do ambiente de desenvolvimento do AWS Cloud9 .
****
| **Tipo de ambiente** | **Siga esses procedimentos** |
| --- | --- |
| Ambiente EC2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/sample-codecommit.html) |
| Ambiente do SSH | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/sample-codecommit.html) |
## Etapa 4: Clonar o repositório remoto no ambiente
Nesta etapa, você usa o AWS Cloud9 IDE para clonar o repositório remoto CodeCommit em seu ambiente.
Para clonar o repositório, execute o comando **`git clone`**. Substitua `CLONE_URL` pelo URL do clone do repositório.
```
git clone CLONE_URL
```
Para um ambiente EC2, forneça um URL de clonagem HTTPS que comece com `https://`. Para um ambiente SSH, forneça um URL de clonagem SSH que comece com `ssh://`.
*Para obter o URL completo do clone do repositório, consulte [Usar o AWS CodeCommit console para visualizar os detalhes do repositório no Guia](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-view-repository-details.html#how-to-view-repository-details-console) do AWS CodeCommit usuário.*
Se seu repositório não tiver nenhum arquivo, uma mensagem de aviso será exibida, como: “`You appear to have cloned an empty repository.` This is expected.” (Parece que você clonou um repositório vazio. Isso é esperado.). Você cuidará disso mais tarde.
## Etapa 5: Adicionar arquivos ao repositório
Nesta etapa, você criará três arquivos simples no repositório clonado no ambiente do AWS Cloud9 . Depois, adicione os arquivos à área de preparação do Git no repositório clonado. Por fim, você confirma os arquivos preparados e envia o commit para o seu repositório remoto em. CodeCommit
Se o repositório clonado já contém arquivos, pule o restante desse exemplo.
**Para adicionar arquivos ao repositório**
1. Criar um novo arquivo. Na barra de menus, selecione **Arquivo**, **Novo arquivo**.
1. Insira o conteúdo a seguir no arquivo e escolha **Arquivo**, **Salvar** para salvar o arquivo como `bird.txt` no `MyDemoCloud9Repo` diretório do seu 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**
Para confirmar que está salvando o arquivo no diretório correto, na caixa de diálogo **Salvar como**, selecione a pasta `MyDemoCloud9Repo`. Depois, certifique-se de que **Pasta** exiba `/MyDemoCloud9Repo`.
1. Crie mais dois arquivos, chamados `insect.txt` e `reptile.txt`, com o conteúdo a seguir. Salve os arquivos no mesmo diretório `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. No terminal, execute o comando **`cd`** para alternar para o diretório `MyDemoCloud9Repo`.
```
cd MyDemoCloud9Repo
```
1. Confirme se os arquivos foram salvos com sucesso no diretório `MyDemoCloud9Repo` executando o comando **`git status`**. Todos os três arquivos serão listados como arquivos não rastreados.
```
Untracked files:
(use "git add ..." to include in what will be committed)
bird.txt
insect.txt
reptile.txt
```
1. Adicione os arquivos à área de preparação do Git executando o comando **`git add`**.
```
git add --all
```
1. Confirme se os arquivos foram adicionados com sucesso à área de preparação do Git executando o comando **`git status`** novamente. Todos os três arquivos agora estão listados como alterações na confirmação.
```
Changes to be committed:
(use "git rm --cached ..." to unstage)
new file: bird.txt
new file: insect.txt
new file: reptile.txt
```
1. Confirme os arquivos preparados executando o comando **`git commit`**.
```
git commit -m "Added information about birds, insects, and reptiles."
```
1. Envie o commit para seu repositório remoto CodeCommit executando o **`git push`**comando.
```
git push -u origin master
```
1. Confirme se os arquivos foram enviado com êxito. Abra o CodeCommit console, se ele ainda não estiver aberto, em [https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit).
1. Na barra de navegação superior, perto da borda direita, escolha Região da AWS onde você criou o repositório (por exemplo, **Leste dos EUA (Ohio))**.
1. Na página **Painel**, escolha **MyDemoCloud9Repo**. Os três arquivos são exibidos.
*Para continuar experimentando com seu CodeCommit repositório, consulte [Navegar pelo conteúdo do seu repositório no Guia](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse) do AWS CodeCommit usuário.*
[Se você é novato Git e não quer bagunçar seu CodeCommit repositório, experimente um repositório de amostra no Git site Try. Git](https://try.github.io/)
## Etapa 6: limpar
Para evitar cobranças contínuas Conta da AWS depois de terminar de usar essa amostra, exclua o CodeCommit repositório. Para obter instruções, consulte [Excluir um AWS CodeCommit repositório](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html) no *Guia do AWS CodeCommit usuário*.
Exclua também o ambiente. Para obter instruções, consulte [Exclusão de um ambiente](delete-environment.md).
# Tutorial do Amazon DynamoDB para AWS Cloud9
Este tutorial permite que você configure um ambiente de AWS Cloud9 desenvolvimento para trabalhar com o Amazon DynamoDB.
O DynamoDB é um serviço de banco de dados NoSQL totalmente gerenciado. Use o DynamoDB para criar uma tabela do banco de dados que possa armazenar e recuperar qualquer quantidade de dados e atender qualquer nível de tráfego solicitado. O DynamoDB distribui automaticamente os dados e tráfego da tabela por um número suficiente de servidores, a fim de lidar com a capacidade da solicitação especificada e com a quantidade de dados armazenados, mantendo uma performance consistente e rápida. Para obter mais informações, consulte [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) no site. AWS
A criação dessa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon EC2 e DynamoDB. Para obter mais informações, consulte [Definição de preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Definição de preço do Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Para obter informações sobre ofertas adicionais AWS de bancos de dados, consulte [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/) no site. AWS Consulte também [AWS Database Migration Service](https://aws.amazon.com/dms/) no site da AWS .
+ [Pré-requisitos](#sample-dynamodb-prereqs)
+ [Etapa 1: Instalar e configurar a AWS CLI, o AWS CloudShell ou ambos no ambiente](#sample-dynamodb-cli-setup)
+ [Etapa 2: Criar uma tabela](#sample-dynamodb-create-table)
+ [Etapa 3: Adicionar um item à tabela](#sample-dynamodb-add-item)
+ [Etapa 4: Adicionar diversos itens à tabela](#sample-dynamodb-add-items)
+ [Etapa 5: Criar um índice secundário global](#sample-dynamodb-create-index)
+ [Etapa 6: Obter itens da tabela](#sample-dynamodb-get-items)
+ [Etapa 7: Limpar](#sample-dynamodb-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: instalar e configurar o AWS CLI AWS CloudShell, o ou ambos em seu ambiente
Nesta etapa, você usa o AWS Cloud9 IDE para instalar e configurar o AWS CLI AWS CloudShell, o ou ambos em seu ambiente para poder executar comandos para interagir com o DynamoDB. Em seguida, use a AWS CLI para executar um comando básico do DynamoDB para testar a instalação e a configuração.
1. Para configurar o gerenciamento de credenciais para o AWS CLI ou o AWS CloudShell e instalar o AWS CLI AWS CloudShell, o ou ambos em seu ambiente, siga as etapas 1 e 2 no [AWS CloudShell exemplo AWS CLI e](sample-aws-cli.md), em seguida, retorne a este tópico. Se você já instalou e configurou o AWS CLI AWS CloudShell, o ou ambos em seu ambiente, não precisa fazer isso novamente.
1. Teste a instalação e a configuração do AWS CLI, do aws-shell ou de ambos executando o **`list-tables`**comando do DynamoDB em uma sessão de terminal em seu ambiente para listar suas tabelas existentes do DynamoDB, se houver alguma. Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Windows (Janelas)**, **New Terminal (Novo terminal)**.
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**nota**
Ao longo dessa amostra, se estiver usando o aws-shell, omita `aws` de cada comando que começa com `aws`. Para iniciar o aws-shell, execute o comando ** `aws-shell` **. Para parar de usar o aws-shell, execute o comando ** `.exit` ** ou ** `.quit` **.
Se esse comando for bem-sucedido, ele gera uma matriz `TableNames` que contém uma lista das tabelas do DynamoDB existentes que você já pode ter. Caso ainda não possua tabelas do DynamoDB, a matriz `TableNames` estará vazia.
```
{
"TableNames": []
}
```
Se você tiver tabelas do DynamoDB, a matriz `TableNames` conterá uma lista dos nomes das tabelas.
## Etapa 2: Criar uma tabela
Nesta etapa, você criará uma tabela no DynamoDB e especificará o nome, o layout, a chave primária simples e as configurações de transferência de dados.
Este exemplo de tabela, chamada `Weather`, contém informações sobre as previsões meteorológicas para algumas cidades nos Estados Unidos. A tabela contém os seguintes tipos de informações (no DynamoDB, cada informação é conhecida como um *atributo*):
+ ID de cidade exclusivo obrigatório (`CityID`)
+ Data da previsão obrigatória (`Date`)
+ Nome da cidade (`City`)
+ Nome do estado (`State`)
+ Condições da previsão meteorológica (`Conditions`)
+ Temperaturas previstas (`Temperatures`)
+ Previsão alta, em graus Fahrenheit (`HighF`)
+ Previsão baixa, em graus Fahrenheit (`LowF`)
Para criar a tabela, em uma sessão de terminal no AWS Cloud9 IDE, execute o 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
```
Neste comando:
+ `--table-name` representa o nome da tabela (`Weather` neste exemplo). Os nomes das tabelas devem ser exclusivos em cada AWS região da sua AWS conta.
+ `--attribute-definitions` representa os atributos que são usados para identificar de forma única os itens da tabela. Cada um dos itens dessa tabela são identificados de forma única por uma combinação de um atributo `ID` numérico e um atributo `Date` representado como uma string formatada em ISO-8601.
+ `--key-schema` representa o esquema de chaves da tabela. Essa tabela tem uma chave primária composta de `CityID` e `Date`. Isso significa que cada um dos itens da tabela deve ter um valor de atributo `CityID` e um valor de atributo `Date`, mas dois itens na tabela não podem ter os mesmos valores de `CityID` e `Date`.
+ `--provisioned-throughput` representa a capacidade de leitura e gravação da tabela. O DynamoDB permite até cinco leituras fortemente consistentes por segundo para itens de até 4 KB de tamanho, ou até cinco leituras eventualmente consistentes por segundo para itens de até 4 KB. O DynamoDB também permite até 5 gravações por segundo para itens de até 1 KB de tamanho.
**nota**
Definir uma taxa de transferência provisionada mais alta pode resultar em cobranças adicionais em sua conta. AWS
Para mais informações sobre esse e outros comandos do DynamoDB, consulte [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html) na *Referência de comandos da AWS CLI *.
Se esse comando for bem-sucedido, ele exibe informações resumidas sobre a nova tabela que está sendo criada. Para confirmar se a tabela foi criada com sucesso, execute o comando ** `describe-table` ** do DynamoDB, especificando o nome da tabela (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Quando a tabela for criada com sucesso, o valor `TableStatus` muda de `CREATING` para `ACTIVE`. Não avance para a próxima etapa até que a tabela seja criada com sucesso.
## Etapa 3: Adicionar um item à tabela
Nesta etapa, adicione um item à tabela que acabou de criar.
1. Crie um arquivo chamado `weather-item.json` com o conteúdo a seguir. Para criar um novo arquivo, na barra de menus, selecione **File (Arquivo)**, **New File (Novo arquivo)**. Para salvar o arquivo, selecione **File (Arquivo)**, **Save (Salvar)**.
```
{
"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" }
}
}
}
```
Neste código, `N` representa um valor de atributo que é um número. `S` é um valor de atributo de string. `M` é um atributo de mapa, que é um conjunto de pares de valores de atributos. É necessário especificar o tipo de dados de um atributo sempre que trabalhar com itens. Para obter os tipos de dados de atributos adicionais disponíveis, consulte [Data Types](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) (Tipos de dados) no *Manual do desenvolvedor do Amazon DynamoDB*.
1. Execute o comando ** `put-item` ** do DynamoDB, especificando o nome da tabela (`--table-name`) e o caminho para o item no formato JSON (`--item`).
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
Se o comando for bem-sucedido, ele é executado sem erros e nenhuma mensagem de confirmação é exibida.
1. Para confirmar o conteúdo atual da tabela, execute o comando ** `scan` ** do DynamoDB, especificando o nome da tabela (`--table-name`).
```
aws dynamodb scan --table-name Weather
```
Se o comando for bem-sucedido, são exibidas informações resumidas sobre a tabela e sobre o item que acabou de adicionar.
## Etapa 4: Adicionar diversos itens à tabela
Nesta etapa, adicione vários outros itens à tabela `Weather`.
1. Crie um arquivo chamado `more-weather-items.json` com o conteúdo a seguir.
```
{
"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" }
}
}
}
}
}
]
}
```
Neste código, oito objetos `Item` definem os oito itens para adicionar à tabela, semelhante ao único item definido na etapa anterior. No entanto, ao executar o comando ** `batch-write-item` ** do DynamoDB na próxima etapa, será necessário fornecer um objeto no formato JSON que inclui cada objeto do `Item` em um objeto `PutRequest` relativo. Em seguida, será necessário incluir os objetos `PutRequest` em uma matriz pai com o mesmo nome que a tabela.
1. Execute o comando ** `batch-write-item` ** do DynamoDB, especificando o caminho para os itens no formato JSON para adicionar (`--request-items`).
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
Se o comando for bem-sucedido, ele exibe a seguinte mensagem, confirmando que os itens foram adicionados com sucesso.
```
{
"UnprocessedItems": {}
}
```
1. Para confirmar o conteúdo atual da tabela, execute o comando ** `scan` ** do DynamoDB novamente.
```
aws dynamodb scan --table-name Weather
```
Se o comando for bem-sucedido, serão exibidos nove itens.
## Etapa 5: Criar um índice secundário global
Executar o comando ** `scan` ** do DynamoDB para obter informações sobre itens pode ser lento, especialmente à medida que uma tabela cresce ou se o tipo de informação que você deseja obter for complexo. Crie um ou mais índices secundários para acelerar o processo e facilitar a obtenção das informações. Nesta etapa, você aprenderá sobre dois tipos de índices secundários compatíveis com DynamoDB para fazer exatamente isso. Eles são conhecidos como um *índice secundário local* e um *índice secundário global*. Em seguida, crie um índice secundário global.
Para entender esses tipos de índices secundários, primeiro é necessário conhecer mais sobre as chaves primárias, que identificam com exclusividade os itens de uma tabela. O DynamoDB oferece suporte a uma *chave primária simples* ou uma *chave primária composta*. Uma chave primária simples possui um único atributo e o valor desse atributo deve ser único para cada item da tabela. Esse atributo também é conhecido como uma *chave de partição* (ou um *atributo de hash*), que o DynamoDB pode usar para particionar os itens para um acesso mais rápido. Uma tabela também pode ter uma chave primária composta, que contém dois atributos. O primeiro atributo é a chave de partição e o segundo é uma *chave de classificação* (também conhecida como um *atributo de intervalo*). Em uma tabela com uma chave primária composta, quaisquer dois itens podem ter o mesmo valor de chave de partição, mas não podem ter o mesmo valor de chave de classificação, simultaneamente. A tabela `Weather` tem uma chave primária composta.
Um índice secundário local tem a mesma chave de partição que a própria tabela, mas esse tipo de índice pode ter uma chave de classificação diferente. Um índice secundário global pode ter uma chave de partição e uma chave de classificação que são ambas diferentes da própria tabela.
Por exemplo, use a chave primária para acessar itens `Weather` por `CityID`. Para acessar os itens `Weather` por `State`, crie um índice secundário local que tenha uma chave de partição de `CityID` (ela deve ser igual à própria tabela) e uma chave de classificação de `State`. Para acessar os itens `Weather` por `City`, crie um índice secundário global que tenha uma chave de partição de `City` e uma chave de classificação de `Date`.
Somente é possível criar índices secundários locais durante a criação de uma tabela. Como a tabela `Weather` já existe, não é possível adicionar índices secundários locais a ela. No entanto, você pode adicionar índices secundários globais. Pratique adicionando um agora mesmo.
**nota**
A criação de índices secundários pode resultar em cobranças adicionais na conta da AWS .
1. Crie um arquivo chamado `weather-global-index.json` com o conteúdo a seguir.
```
[
{
"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
}
}
}
]
```
Neste código:
+ O nome do índice secundário global é `weather-global-index`.
+ O atributo `City` é a chave de partição (atributo de hash) e o atributo `Date` é a chave de classificação (atributo de intervalo).
+ `Projection` define os atributos a serem recuperados por padrão (além do atributo de hash e qualquer atributo de intervalo) para todos os itens correspondentes a uma pesquisa de tabela que usa esse índice. Neste exemplo, os atributos `State`, `Conditions`, `HighF` (parte do `Temperatures`) e `LowF` (também parte do `Temperatures`) (bem como os atributos `City` e `Date`) são recuperados para cada item correspondente.
+ Semelhante às tabelas, um índice secundário global deve definir as configurações de transferência provisionada.
+ As configurações `IndexName`, `KeySchema`, `Projection` e `ProvisionedThroughput` devem estar contidas em um objeto `Create`, que define o índice secundário global a ser criado na execução do comando ** `update-table` ** do DynamoDB na próxima etapa.
1. Execute o comando ** `update-table` ** do 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
```
Neste comando:
+ `--table-name` é o nome da tabela para atualização.
+ `--attribute-definitions` são os atributos a serem incluídos no índice. A chave de partição sempre é listada primeiro e qualquer chave de classificação é sempre listada em segundo.
+ `--global-secondary-index-updates` é o caminho para o arquivo que define o índice secundário global.
Se esse comando for bem-sucedido, ele exibe informações resumidas sobre o novo índice secundário global que está sendo criado. Para confirmar se o índice secundário global foi criado com sucesso, execute o comando ** `describe-table` ** do DynamoDB, especificando o nome da tabela (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Quando o índice secundário global for criado com sucesso, o valor `TableStatus` muda de `UPDATING` para `ACTIVE` e o valor `IndexStatus` muda de `CREATING` para `ACTIVE`. Não avance para a próxima etapa até que o índice secundário global seja criado com sucesso. Isso pode demorar vários minutos.
## Etapa 6: Obter itens da tabela
Existem muitas formas de obter itens das tabelas. Nesta etapa, obtenha os itens usando a chave primária da tabela ao usar os outros atributos da tabela e o índice secundário global.
### Para obter um único item de uma tabela com base no valor da chave primária do item
Se você souber o valor da chave primária de um item, você poderá obter o item correspondente, executando o comando ** `get-item` **, ** `scan` ** ou ** `query` ** do DynamoDB. Veja a seguir as principais diferenças nesses comandos:
+ ** `get-item` ** retorna um conjunto de atributos para o item com a chave primária fornecida.
+ ** `scan` ** retorna um ou mais itens e atributos de item ao acessar cada item em uma tabela ou um índice secundário.
+ ** `query` ** encontra itens com base nos valores de chave primária. Consulte qualquer tabela ou índice secundário que tenha uma chave primária composta (uma chave de partição e uma de classificação).
Neste exemplo, veja como usar cada um desses comandos para obter o item que contém o valor do atributo `CityID` de `1` e o valor do atributo `Date` de `2017-04-12`.
1. Para executar o comando ** `get-item` ** do DynamoDB, especifique o nome da tabela (`--table-name`), o valor da chave primária (`--key`) e os valores do atributo do item para exibição (`--projection-expression`). Como `Date` é uma palavra-chave reservada no DynamoDB você também deverá fornecer um alias para o valor do atributo `Date` (`--expression-attribute-names`). (O `State` também é uma palavra-chave reservada e, portanto, você verá um alias fornecido a ela em etapas posteriores).
```
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" }'
```
Neste e em outros comandos, para exibir todos os atributos do item, não inclua `--projection-expression`. Neste exemplo, como `--projection-expression` não está incluso, também não é necessário incluir `--expression-attribute-names`.
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. Para executar o comando ** `scan` ** do DynamoDB, especifique:
+ O nome da tabela (`--table-name`).
+ A pesquisa a ser executada (`--filter-expression`).
+ Os critérios de pesquisa a serem usados (`--expression-attribute-values`).
+ Os tipos de atributos a serem exibidos para o item correspondente (`--select`).
+ Os valores de atributo do item a serem exibidos (`--projection-expression`).
+ Se qualquer um dos atributos estiver usando palavras-chave reservadas em aliases do DynamoDB para esses atributos (`--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. Para executar o comando ** `query` ** do DynamoDB, especifique:
+ O nome da tabela (`--table-name`).
+ A pesquisa a ser executada (`--key-condition-expression`).
+ Os valores de atributo a serem usados na pesquisa (`--expression-attribute-values`).
+ Os tipos de atributos a serem exibidos para o item correspondente (`--select`).
+ Os valores de atributo do item a serem exibidos (`--projection-expression`).
+ Se qualquer um dos atributos estiver usando palavras-chave reservadas em aliases do DynamoDB para esses atributos (`--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" }'
```
Observe que o comando ** `scan` ** precisou verificar todos os nove itens para obter o resultado, enquanto o comando ** `query` ** precisou verificar apenas um item.
### Para obter diversos itens de uma tabela com base nos valores de chave primária dos itens
Se você souber os valores de chave primária dos itens, poderá obter os itens correspondentes, executando o comando ** `batch-get-item` ** do DynamoDB. Neste exemplo, veja como obter os itens que contêm o valor do atributo `CityID` de `3` e valores do atributo `Date` de `2017-04-13` ou `2017-04-14`.
Execute o comando ** `batch-get-item` **, especificando o caminho para um arquivo que descreve os itens a serem obtidos (`--request-items`).
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
Para este exemplo, o código no arquivo `batch-get-item.json` especifica a pesquisa na tabela `Weather` dos itens com um `CityID` de `3` e uma `Date` de `2017-04-13` ou `2017-04-14`. Para cada item encontrado, os valores de atributo para `City`, `State`, `Date` e `HighF` (parte do `Temperatures`) são exibidos, se existirem.
```
{
"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" }
}
}
```
### Para obter todos os itens correspondentes de uma tabela
Se você souber algo sobre os valores de atributos na tabela, você poderá obter os itens correspondentes, executando o comando ** `scan` ** do DynamoDB. Neste exemplo, veja como obter as datas quando o valor do atributo `Conditions` contém `Sunny` e o valor do atributo `HighF` (parte do `Temperatures`) é maior que `53`.
Execute o comando ** `scan` ** do DynamoDB, especificando:
+ O nome da tabela (`--table-name`).
+ A pesquisa a ser executada (`--filter-expression`).
+ Os critérios de pesquisa a serem usados (`--expression-attribute-values`).
+ Os tipos de atributos a serem exibidos para o item correspondente (`--select`).
+ Os valores de atributo do item a serem exibidos (`--projection-expression`).
+ Se qualquer um dos atributos estiver usando palavras-chave reservadas em aliases do DynamoDB para esses atributos (`--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" }'
```
### Para obter todos os itens correspondentes de um índice secundário global
Para pesquisar usando um índice secundário global, use o comando ** `query` ** do DynamoDB. Neste exemplo, veja como usar o índice secundário `weather-global-index` para obter as condições de previsão para cidades com o nome `Portland` e para as datas de `2017-04-13` e `2017-04-14`.
Execute o comando ** `query` ** do DynamoDB, especificando:
+ O nome da tabela (`--table-name`).
+ O nome do índice secundário global (`--index-name`).
+ A pesquisa a ser executada (`--key-condition-expression`).
+ Os valores de atributo a serem usados na pesquisa (`--expression-attribute-values`).
+ Os tipos de atributos a serem exibidos para o item correspondente (`--select`).
+ Se qualquer um dos atributos estiver usando palavras-chave reservadas em aliases do DynamoDB para esses atributos (`--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" }'
```
## Etapa 7: Limpar
Para evitar cobranças contínuas em sua AWS conta depois que você terminar de usar essa amostra, exclua a tabela. Excluir a tabela também excluirá o índice secundário global. Exclua também o ambiente.
Para excluir a tabela, execute o comando ** `delete-table` ** do DynamoDB, especificando o nome da tabela (`--table-name`).
```
aws dynamodb delete-table --table-name Weather
```
Se o comando for bem-sucedido, serão exibidas informações sobre a tabela, incluindo o valor do `TableStatus` de `DELETING`.
Para confirmar se a tabela foi excluída com sucesso, execute o comando ** `describe-table` ** do DynamoDB, especificando o nome da tabela (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Se a tabela for excluída com sucesso, será exibida uma mensagem que contém a frase `Requested resource not found`.
Para excluir o ambiente, consulte [Deleting an Environment](delete-environment.md) (Excluir um ambiente).
# AWS CDK tutorial para AWS Cloud9
Este tutorial mostra como trabalhar com o AWS Cloud Development Kit (AWS CDK) em um ambiente de AWS Cloud9 desenvolvimento. AWS CDK É um conjunto de ferramentas e bibliotecas de software que os desenvolvedores podem usar para modelar componentes de AWS infraestrutura como código.
AWS CDK Isso inclui a AWS Construct Library, que você pode usar para resolver rapidamente muitas tarefas AWS. Por exemplo, é possível usar o constructo `Fleet` para implantar totalmente e de forma segura o código em uma frota de hosts. Você pode criar seus próprios constructos para modelar vários elementos de suas arquiteturas, compartilhá-los com outras pessoas ou publicá-los na comunidade. Para obter mais informações, consulte o [Guia do usuário do Kit de Desenvolvimento da Nuvem AWS](https://docs.aws.amazon.com/cdk/v2/guide/home.html).
Seguir este tutorial e criar este exemplo pode gerar cobranças em sua conta da AWS . Isso inclui possíveis cobranças por serviços como o Amazon EC2, Amazon SNS e Amazon SQS. Para obter mais informações, consulte a [Definição de preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/), a [Definição de preço do Amazon SNS](https://aws.amazon.com/sns/pricing/) e a [Definição de preço do Amazon SQS](https://aws.amazon.com/sqs/pricing/).
**Topics**
+ [Pré-requisitos](#sample-cdk-prereqs)
+ [Etapa 1: Instalar as ferramentas necessárias](#sample-cdk-install)
+ [Etapa 2: Adicionar código](#sample-cdk-code)
+ [Etapa 3: Executar o código](#sample-cdk-run)
+ [Etapa 4: limpar](#sample-cdk-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar as ferramentas necessárias
Nesta etapa, você instala todas as ferramentas necessárias em seu ambiente para executar uma amostra escrita na linguagem de TypeScript programação. AWS CDK
1. [Gerenciador de versão do Node](#sample-cdk-install-nvm) ou ** `nvm` ** que você usa para instalar o Node.js posteriormente.
1. [Node.js](#sample-cdk-install-nodejs), que é exigido pela amostra e contém o Node Package Manager **`npm`**, ou, que você usa para instalar TypeScript e o AWS CDK posterior.
1. [TypeScript](#sample-cdk-install-typescript), o que é exigido por esta amostra. ( AWS CDK Também fornece suporte para várias outras linguagens de programação.)
1. O [AWS CDK](#sample-cdk-install-cdk).
### Etapa 1.1: Instale o Gerenciador de versão do Node (nvm)
1. Em uma sessão de terminal no AWS Cloud9 IDE, certifique-se de que as atualizações de segurança e correções de erros mais recentes estejam instaladas. Para fazer isso, execute o comando ** `yum update` ** para Amazon Linux ou ** `apt update` ** para Ubuntu Server. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.)
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Confirme se o ** `nvm` ** já está instalado. Para fazer isso, execute o comando ** `nvm` ** com a opção ** `--version` **.
```
nvm --version
```
Se for bem-sucedido, a saída conterá o número da versão do ** `nvm` **, e você poderá ir direto para [Etapa 1.2: Instalar o Node.js](#sample-cdk-install-nodejs).
1. Faça download e instale ** `nvm` **. Para fazer isso, execute o script de instalação. Neste exemplo, a versão v0.33.0 é instalada, mas é possível verificar a versão mais recente do ** `nvm` ** [aqui](https://github.com/nvm-sh/nvm#installing-and-updating).
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Comece a utilizar ** `nvm` **. Você pode fechar a sessão de terminal e depois iniciá-la novamente ou extrair o arquivo `~/.bashrc` que contém os comandos para carregar o ** `nvm` **.
```
. ~/.bashrc
```
### Etapa 1.2: Instalar o Node.js
1. Confirme se você já tem o Node.js instalado e, se tiver, confirme se a versão instalada é a 16.17.0 ou posterior. **Este exemplo foi testado no Node.js 16.17.0.** Para verificar, com a sessão de terminal ainda aberta no IDE, execute o comando ** `node` ** com a opção ** `--version` **.
```
node --version
```
Se já tem o Node.js instalado, a saída contém o número da versão. Se o número da versão for v16.17.0, avance para [Etapa 1.3: Instalar TypeScript](#sample-cdk-install-typescript).
1. Instale o Node.js 16 executando o comando ** `nvm` ** com a ação ** `install` **.
**nota**
Você também pode executar **`nvm install node`**para instalar a versão de suporte de longo prazo (LTS) do Node.js. AWS Cloud9 o suporte rastreia a versão LTS do Node.js.
```
nvm install v16
```
1. Comece a usar o Node.js 16. Para fazer isso, execute o comando ** `nvm` ** com a ação ** `alias` **, o número da versão para alias e a versão a ser usada para esse alias, como mostrado a seguir.
```
nvm alias default 16
```
**nota**
O comando anterior define o Node.js 16 como a versão padrão do Node.js. Como alternativa, é possível executar o comando ** `nvm` ** juntamente com a ação ** `use` **, em vez da ação ** `alias` ** (por exemplo, ** `nvm use 16.17.0` **). No entanto, a ação ** `use` ** faz com que essa versão do Node.js execute apenas durante a execução da sessão de terminal atual.
1. Para confirmar se está usando o Node.js 16, execute o comando ** `node --version` ** novamente. Se a versão correta estiver instalada, a saída conterá a versão v16.
### Etapa 1.3: Instalar TypeScript
1. Confirme se você já TypeScript instalou. Para fazer isso, com a sessão do terminal ainda aberta no IDE, execute o TypeScript compilador da linha de comando com a **`--version`**opção.
```
tsc --version
```
Se você tiver TypeScript instalado, a saída conterá o número da TypeScript versão. Se TypeScript estiver instalado, vá para[Etapa 1.4: Instalar o AWS CDK](#sample-cdk-install-cdk).
1. Instalar TypeScript. Para fazer isso, execute o **`npm`**comando com a **`install`**ação, a **`-g`**opção e o nome do TypeScript pacote. Isso é instalado TypeScript como um pacote global no ambiente.
```
npm install -g typescript
```
1. Confirme se TypeScript está instalado. Para fazer isso, execute o TypeScript compilador de linha de comando com a **`--version`**opção.
```
tsc --version
```
Se TypeScript estiver instalado, a saída conterá o número da TypeScript versão.
### Etapa 1.4: Instalar o AWS CDK
1. Confirme se você já tem o AWS CDK instalado. Para fazer isso, com a sessão de terminal ainda aberta no IDE, execute o comando ** `cdk` ** com a opção ** `--version` **.
```
cdk --version
```
Se o AWS CDK estiver instalado, a saída conterá a AWS CDK versão e os números de compilação. Avance para [Etapa 2: Adicionar código](#sample-cdk-code).
1. Instale o AWS CDK executando o **`npm`**comando junto com a `install` ação, o nome do AWS CDK pacote a ser instalado e a `-g` opção de instalar o pacote globalmente no ambiente.
```
npm install -g aws-cdk
```
1. Confirme se o AWS CDK está instalado e referenciado corretamente. Para fazer isso, execute o comando ** `cdk` ** com a opção ** `--version` **.
```
cdk --version
```
Se for bem-sucedido, os números da AWS CDK versão e da versão serão exibidos.
## Etapa 2: Adicionar código
Nesta etapa, você cria um TypeScript projeto de amostra que contém todo o código-fonte necessário para AWS CDK implantar programaticamente uma AWS CloudFormation pilha. Essa pilha cria um tópico do Amazon SNS e uma fila do Amazon SQS em AWS sua conta e, em seguida, inscreve a fila no tópico.
1. Com a sessão de terminal ainda aberta no IDE, crie um diretório para armazenar o código-fonte do projeto, por exemplo, um diretório `~/environment/hello-cdk` no seu ambiente. Depois, mude para esse diretório.
```
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. Configure o diretório como um projeto de TypeScript linguagem para AWS CDK o. Para fazer isso, execute o comando ** `cdk` ** com a ação ** `init` **, o modelo ** `sample-app` ** e a opção ** `--language` ** com o nome da linguagem de programação.
```
cdk init sample-app --language typescript
```
Isso cria os seguintes arquivos e subdiretórios no diretório:
+ Um subdiretório `.git` oculto e um arquivo `.gitignore` oculto, que torna o projeto compatível com ferramentas de controle de fonte como o Git.
+ Um subdiretório `lib`, que inclui um arquivo `hello-cdk-stack.ts`. Esse arquivo contém o código da sua AWS CDK pilha. Esse código é descrito na próxima etapa neste procedimento.
+ Um subdiretório `bin`, que inclui um arquivo `hello-cdk.ts`. Esse arquivo contém o ponto de entrada do seu AWS CDK aplicativo.
+ Um subdiretório `node_modules`, que contém pacotes de código de suporte que o aplicativo e a pilha podem usar conforme necessário.
+ Um arquivo `.npmignore` oculto, que lista os tipos de subdiretórios e arquivos que o ** `npm` ** não precisa quando cria o código.
+ Um arquivo `cdk.json`, que contém informações para facilitar a execução do comando ** `cdk` **.
+ Um arquivo `package-lock.json`, que contém informações que o ** `npm` ** pode usar para reduzir possíveis erros de compilação e execução.
+ Um arquivo `package.json`, que contém informações para facilitar a execução do comando ** `npm` ** e possivelmente diminuir os erros de compilação e execução.
+ Um `README.md` arquivo, que lista comandos úteis com os quais você pode executar **`npm`**e AWS CDK o.
+ Um arquivo `tsconfig.json`, que contém informações para facilitar a execução do comando ** `tsc` ** e possivelmente diminuir os erros de compilação e execução.
1. Na janela **Ambiente**, abra o arquivo `lib/hello-cdk-stack.ts` e procure o código a seguir.
```
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);
}
}
```
+ As `Topic` classes `Stack``App`,`StackProps`,`Queue`, e representam uma CloudFormation pilha e suas propriedades, um programa executável, uma fila do Amazon SQS e um tópico do Amazon SNS, respectivamente.
+ A `HelloCdkStack` classe representa a CloudFormation pilha desse aplicativo. Essa pilha contém a nova fila do Amazon SQS e o tópico do Amazon SNS para esta aplicação.
1. Na janela **Ambiente**, abra o arquivo `bin/hello-cdk.ts` e procure o código a seguir.
```
#!/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();
```
Esse código carrega, cria uma instância e executa a classe `HelloCdkStack` do arquivo `lib/hello-cdk-stack.ts`.
1. Use **`npm`**para executar o TypeScript compilador para verificar se há erros de codificação e, em seguida, habilite o AWS CDK para executar o arquivo do `bin/hello-cdk.js` projeto. Para fazer isso, no diretório raiz do projeto, execute o comando ** `npm` ** com a ação ** `run` **, especificando o valor do comando ** `build` ** no arquivo `package.json`, conforme mostrado a seguir.
```
npm run build
```
O comando anterior executa o TypeScript compilador, que adiciona suporte `bin/hello-cdk.d.ts` e `lib/hello-cdk-stack.d.ts` arquivos. O compilador também desmembra os arquivos `hello-cdk.ts` e `hello-cdk-stack.ts` nos arquivos `hello-cdk.js` e `hello-cdk-stack.js`.
## Etapa 3: Executar o código
Nesta etapa, você instrui o a AWS CDK criar um modelo de CloudFormation pilha com base no código no `bin/hello-cdk.js` arquivo. Em seguida, você instrui o AWS CDK a implantar a pilha, que cria o tópico do Amazon SNS e a fila do Amazon SQS e, em seguida, inscreve a fila no tópico. Depois, confirme se o tópico e a fila foram implantados com êxito, enviando uma mensagem do tópico para a fila.
1. Peça AWS CDK para criar o modelo CloudFormation de pilha. Para fazer isso, com a sessão de terminal ainda aberta no IDE, no diretório raiz do projeto, execute o comando ** `cdk` ** com a ação ** `synth` ** e o nome da pilha.
```
cdk synth HelloCdkStack
```
Se for bem-sucedida, a saída exibirá a `Resources` seção do modelo de CloudFormation pilha.
1. Na primeira vez que você implanta um AWS CDK aplicativo em um ambiente para uma combinação específica de AWS conta e AWS região, você deve instalar uma *pilha de bootstrap*. Essa pilha inclui vários recursos AWS CDK necessários para concluir suas várias operações. Por exemplo, essa pilha inclui um bucket Amazon S3 que é AWS CDK usado para armazenar modelos e ativos durante seus processos de implantação. Para instalar a pilha de bootstrap, execute o comando ** `cdk` ** com a ação de ** `bootstrap` **.
```
cdk bootstrap
```
**nota**
Se você executar `cdk bootstrap` sem especificar nenhuma opção, a AWS conta e a AWS região padrão serão usadas. Você também pode inicializar um ambiente específico especificando um perfil e account/Region uma combinação. Por exemplo:
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. Faça com que AWS CDK execute o modelo de CloudFormation pilha para implantar a pilha. Para fazer isso, no diretório raiz do projeto, execute o comando ** `cdk` ** com a ação ** `deploy` ** e o nome da pilha.
```
cdk deploy HelloCdkStack
```
Se for bem-sucedido, a saída exibe que a pilha `HelloCdkStack` foi implantada sem erros.
**nota**
Se a saída exibir uma mensagem informando que a pilha não define um ambiente e que AWS as credenciais não puderam ser obtidas em locais padrão ou que nenhuma região foi configurada, verifique se suas AWS credenciais estão definidas corretamente no IDE e execute o **`cdk deploy`**comando novamente. Para obter mais informações, consulte [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md).
1. Para confirmar se o tópico do Amazon SNS e a fila do Amazon SQS foram implantados com êxito, envie uma mensagem ao tópico e consulte a fila para verificar se a mensagem foi recebida. Para fazer isso, você pode usar uma ferramenta como o AWS Command Line Interface (AWS CLI) ou AWS CloudShell o. Para mais informações sobre essas ferramentas, consulte [AWS CLI e tutorial aws-shell para AWS Cloud9](sample-aws-cli.md).
Por exemplo, para enviar uma mensagem para o tópico, com a sessão do terminal ainda aberta no IDE, use o AWS CLI para executar o **`publish`**comando Amazon SNS, fornecendo o assunto e o corpo da mensagem, a AWS região do tópico e o nome de recurso da Amazon (ARN) do tópico.
```
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
```
No comando anterior, `arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K` substitua pelo ARN atribuído CloudFormation ao tópico. Para obter o ID, você pode executar o comando ** `list-topics` ** do Amazon SNS.
```
aws sns list-topics --output table --query 'Topics[*].TopicArn'
```
Se for bem-sucedido, a saída do comando ** `publish` ** exibe o valor `MessageId` para a mensagem que foi publicada.
Para verificar se a fila recebeu a mensagem, execute o comando ** `receive-message` ** do Amazon SQS, fornecendo o URL da fila.
```
aws sqs receive-message --queue-url https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K
```
No comando anterior, `https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K` substitua pelo ARN atribuído CloudFormation à fila. Para obter o URL, você pode executar o comando ** `list-queues` ** do Amazon SQS.
```
aws sqs list-queues --output table --query 'QueueUrls[*]'
```
Se for bem-sucedido, a saída do comando ** `receive-message` ** exibe as informações sobre a mensagem que foi recebida.
## Etapa 4: limpar
Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar essa amostra, você deve excluir a CloudFormation pilha. Isso exclui o tópico do Amazon SNS e a fila do Amazon SQS. Exclua também o ambiente.
### Etapa 4.1: Excluir a pilha
Com a sessão de terminal ainda aberta no IDE, no diretório raiz do projeto, execute o comando ** `cdk` ** com a ação ** `destroy` ** e o nome da pilha.
```
cdk destroy HelloCdkStack
```
Quando solicitado a excluir a pilha, digite `y` e depois pressione `Enter`.
Se for bem-sucedido, a saída exibe que a pilha `HelloCdkStack` foi excluída sem erros.
### Etapa 4.2: Excluir o ambiente
Para excluir o ambiente, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# Tutorial LAMP para AWS Cloud9
Este tutorial permite que você configure e execute LAMP (Linux, Apache Servidor HTTP, MySQL e PHP) dentro de um ambiente AWS Cloud9 de desenvolvimento.
Seguir este tutorial e criar essa amostra pode resultar em cobranças para você Conta da AWS. Isso inclui possíveis cobranças Serviços da AWS , como Amazon Elastic Compute Cloud (Amazon EC2). Para obter mais informações, consulte [Amazon EC2 Pricing](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Pré-requisitos](#sample-lamp-prereqs)
+ [Etapa 1: Instalar as ferramentas](#sample-lamp-install-tools)
+ [Etapa 2: configurar MySQL](#sample-lamp-setup-mysql)
+ [Etapa 3: Configurar um site](#sample-lamp-apache)
+ [Etapa 4: limpar](#sample-lamp-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de AWS Cloud9 EC2 desenvolvimento existente.** Este exemplo pressupõe que você já tenha um EC2 ambiente conectado a uma EC2 instância da Amazon que executa o Amazon Linux ou Ubuntu Servidor. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar as ferramentas
Nesta etapa, instale as seguintes ferramentas:
+ Apache Servidor HTTP, um host de servidor web.
+ PHP, uma linguagem de script que é especialmente adequada para o desenvolvimento na web e pode ser incorporada em HTML.
+ MySQL, um sistema de gerenciamento de banco de dados.
Em seguida, você conclui esta etapa iniciando Apache Servidor HTTP e depois MySQL.
1. Garanta que as últimas atualizações de segurança e correções de bugs estão instaladas na instância. Para fazer isso, em uma sessão de terminal no AWS Cloud9 IDE, execute o **`yum update`**for (Amazon Linux) ou **`apt update`**for (Ubuntu Comando (servidor). (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.)
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Servidor:
```
sudo apt -y update
```
1. Verifique se Apache O servidor HTTP já está instalado. Para fazer isso, execute o **`httpd -v`**(para Amazon Linux) ou **`apache2 -v`**(para Ubuntu Comando (servidor).
Se for bem-sucedida, a saída conterá o Apache Número da versão do servidor HTTP.
Se você ver um erro, instale Apache Servidor HTTP executando o **`install`**comando.
Para Amazon Linux:
```
sudo yum install -y httpd24
```
Para Ubuntu Servidor:
```
sudo apt install -y apache2
```
1. Confirme se PHP já está instalado executando o **`php -v`**comando.
Se sim, a saída contém o número da versão PHP.
Se você vir um erro, instale o PHP executando o comando **`install`**.
Para Amazon Linux:
```
sudo yum install -y php56
```
Para Ubuntu Servidor:
```
sudo apt install -y php libapache2-mod-php php-xml
```
1. Confirme se MySQL já está instalado executando o **`mysql --version`**comando.
Se for bem-sucedida, a saída conterá o MySQL número da versão.
Se você ver um erro, instale MySQL executando o **`install`**comando.
Para Amazon Linux:
```
sudo yum install -y mysql-server
```
Para Ubuntu Servidor:
```
sudo apt install -y mysql-server
```
1. Depois de instalar Apache Servidor HTTP, PHP e MySQL, começar Apache Servidor HTTP e, em seguida, confirme que ele foi iniciado, executando o comando a seguir.
Para Amazon Linux (talvez seja necessário executar o comando duas vezes):
```
sudo service httpd start && sudo service httpd status
```
Para Ubuntu Servidor (para retornar ao prompt de comando, pressione`q`):
```
sudo service apache2 start && sudo service apache2 status
```
1. Início MySQLe, em seguida, confirme que foi iniciado, executando o comando a seguir.
Para Amazon Linux:
```
sudo service mysqld start && sudo service mysqld status
```
Para Ubuntu Servidor (para retornar ao prompt de comando, pressione`q`):
```
sudo service mysql start && sudo service mysql status
```
## Etapa 2: configurar MySQL
Nesta etapa, você configura MySQL para seguir MySQL melhores práticas de segurança. Essas práticas recomendadas de segurança incluem a definição de uma senha para contas raiz e a remoção de contas raiz que podem ser acessadas de fora do host local. Outras práticas recomendadas a serem observadas são remover usuários anônimos, remover o banco de dados de teste e remover privilégios que permitem que qualquer pessoa acesse bancos de dados com nomes que começam com `test_`.
Em seguida, você conclui esta etapa praticando o início e a saída do MySQL cliente de linha de comando.
1. Implementar MySQL melhores práticas de segurança para o MySQL instalação executando o seguinte comando em uma sessão de terminal no AWS Cloud9 IDE.
```
sudo mysql_secure_installation
```
1. Quando solicitado, responda às seguintes perguntas conforme especificado.
Para Amazon Linux:
1. **Insira a senha atual para raiz (Enter para nenhuma)** – Pressione `Enter` (quando não houver senha).
1. **Definir senha raiz** – Digite `Y` e pressione `Enter`.
1. **Nova senha** Digite uma senha e pressione `Enter`.
1. **Digite novamente a nova senha**: digite a senha novamente e pressione `Enter`. (Certifique-se de armazenar a senha em um local seguro para uso posterior.)
1. **Remover usuários anônimos** – Digite `Y` e pressione `Enter`.
1. **Desautorizar o login raiz remotamente** – Digite `Y` e pressione `Enter`.
1. **Remover o banco de dados de teste e o acesso a ele** – Digite `Y` e pressione `Enter`.
1. **Recarregar tabelas de privilégio agora** – Digite `Y` e pressione `Enter`.
Para Ubuntu Servidor:
1. **Deseja configurar o plug-in VALIDATE PASSWORD?** Insira `y` e pressione `Enter`.
1. **Há três níveis de política de validação de senha**: insira `0`, `1` ou `2`, e pressione `Enter`.
1. **Nova senha**: insira uma senha e pressione `Enter`.
1. **Insira novamente a nova senha**: insira a senha novamente e pressione `Enter`. Certifique-se de armazenar a senha em um local seguro para uso posterior.
1. **Deseja continuar com a senha fornecida?** Insira `y` e pressione `Enter`.
1. **Remover usuários anônimos**: insira `y` e pressione `Enter`.
1. **Desautorizar o login raiz remotamente**: insira `y` e pressione `Enter`.
1. **Remover o banco de dados de teste e o acesso a ele**: insira `y` e pressione `Enter`.
1. **Recarregar tabelas de privilégio agora**: insira `y` e pressione `Enter`.
1. Para interagir diretamente com MySQL, inicie o MySQL cliente de linha de comando como usuário root executando o comando a seguir. Quando solicitado, digite a senha do usuário raiz definida anteriormente e pressione `Enter`. O prompt muda para `mysql>` enquanto você está no MySQL cliente de linha de comando.
```
sudo mysql -uroot -p
```
1. Para sair do MySQL cliente de linha de comando, execute o seguinte comando. O prompt muda de volta para `$`.
```
exit;
```
## Etapa 3: Configurar um site
Nesta etapa, você configura a raiz padrão do site para o Apache Servidor HTTP com proprietários e permissões de acesso recomendados. Em seguida, você cria um PHPpágina da web baseada nessa raiz padrão do site.
Em seguida, você habilita o tráfego de entrada da web para visualizar essa página da web configurando o grupo de segurança na Amazon EC2 e a lista de controle de acesso à rede (ACL de rede) na Amazon Virtual Private Cloud (Amazon VPC) que estão associados a esse ambiente. EC2 Cada EC2 ambiente deve estar associado a um grupo de segurança na Amazon EC2 e a uma rede ACL na Amazon VPC. No entanto, mesmo que a ACL de rede padrão em uma Conta da AWS permita todo o tráfego de entrada e saída para o ambiente, o grupo de segurança padrão permitirá apenas o tráfego de entrada usando SSH na porta 22. Para obter mais informações, consulte [Configurações de VPC para ambientes de desenvolvimento AWS Cloud9](vpc-settings.md).
Essa etapa será finalizada quando você conseguir visualizar a página da Web de fora do IDE do AWS Cloud9 .
1. Configure a raiz padrão do site para o Apache Servidor HTTP (`/var/www/html`) com proprietários e permissões de acesso recomendados. Para fazer isso, execute os seis comandos a seguir, um por vez na seguinte ordem, em uma sessão de terminal no AWS Cloud9 IDE. Para entender o que cada comando faz, leia as informações após o caractere `#` depois de cada comando.
Para 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.
```
Para Ubuntu Servidor:
```
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. Crie um PHPpágina da web baseada `index.php` na pasta raiz padrão do site para o Apache Servidor HTTP (que é`/var/www/html`) executando o seguinte comando.
Para 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
```
O comando anterior para o Amazon Linux também altera o proprietário do arquivo para`ec2-user`, altera o grupo do arquivo para `web-content` e altera as permissões do arquivo read/write for the user, and read/execute para o grupo e outros.
Para Ubuntu Servidor:
```
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
```
O comando anterior para Ubuntu O servidor também altera o proprietário do arquivo para`ubuntu`, altera o grupo do arquivo para `web-content` e altera as permissões do arquivo read/write for the user, and read/execute para o grupo e outros.
Se for bem-sucedido, os comandos anteriores criarão o arquivo `index.php` com o seguinte conteúdo.
```
```
1. Ative o tráfego de entrada da web pela porta 80 para visualizar a nova página da web configurando a rede ACL na Amazon VPC e o grupo de segurança Amazon associado a EC2 esse ambiente. EC2 Para fazer isso, execute os seguintes oito comandos, um de cada vez e na seguinte ordem. Para entender o que cada comando faz, leia as informações após o caractere `#` para cada comando.
**Importante**
A execução dos comandos a seguir permite o tráfego de entrada da web pela porta 80 para **todos os** EC2 ambientes e EC2 instâncias da Amazon associados ao grupo de segurança e à rede ACL desse ambiente. Isso pode resultar na ativação inesperada do tráfego web de entrada pela porta 80 para ambientes EC2 e EC2 instâncias da Amazon que não sejam este.
**nota**
Os seguintes comandos, do segundo ao quarto, habilitam o grupo de segurança para permitir o tráfego da web de entrada na porta 80. Se você tiver um grupo de segurança padrão, que só permite o tráfego de entrada SSH na porta 22, você deverá executar o primeiro comando seguido por esses comandos do segundo ao quarto. No entanto, se você tiver um grupo de segurança personalizado que já permite o tráfego da web de entrada na porta 80, poderá pular a execução desses comandos.
Os seguintes comandos, do quinto ao oitavo, habilitam a ACL da rede para permitir o tráfego da Web de entrada na porta 80. Se você tiver uma Network ACL padrão, que já permite todo o tráfego de entrada em todas as portas, você poderá ignorar com segurança a execução desses comandos. No entanto, suponha que você tenha uma ACL de rede personalizada que não permite o tráfego da web de entrada na porta 80. Depois, execute o primeiro comando seguido da sequência do quinto ao oitavo comando.
```
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. Obtenha o URL para o arquivo `index.php` na raiz do servidor da web. Para fazer isso, execute o comando a seguir e use uma nova guia do navegador da Web ou um navegador da Web diferente separado do AWS Cloud9 IDE para acessar a URL exibida. Se for bem-sucedida, a página da Web exibirá informações sobre Apache Servidor HTTP, MySQL, PHPe outras configurações relacionadas.
```
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.
```
## Etapa 4: limpar
Suponha que você queira continuar usando esse ambiente, mas queira desativar o tráfego de entrada da web pela porta 80. Execute os oito comandos a seguir, um de cada vez e na ordem em que estão, para excluir as regras de tráfego de entrada correspondentes que você definiu anteriormente no grupo de segurança e ACL da rede associados ao ambiente. Para entender o que cada comando faz, leia as informações após o caractere `#` para cada comando.
**Importante**
A execução dos comandos a seguir desativa o tráfego da web de entrada pela porta 80 para **todos os** EC2 ambientes e EC2 instâncias da Amazon associados ao grupo de segurança e à rede ACL desse ambiente. Isso pode resultar na desativação inesperada do tráfego web de entrada pela porta 80 para ambientes EC2 e EC2 instâncias da Amazon que não sejam este.
**nota**
A sequência do quinto ao oitavo comando a seguir remove as regras existentes para impedir que a ACL de rede permita o tráfego da web de entrada na porta 80. Se você tiver uma ACL de rede padrão que já permite todo o tráfego de entrada em todas as portas, poderá ignorar a execução desses comandos. No entanto, suponha que você tenha uma ACL de rede personalizada com regras existentes que permitem o tráfego da web de entrada pela porta 80 e deseje excluir essas regras. Você precisa executar o primeiro comando seguido da sequência do quinto ao oitavo comando.
```
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.
```
Quando terminar de usar este ambiente, exclua-o para evitar cobranças contínuas em sua Conta da AWS. Para obter instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# WordPress tutorial para AWS Cloud9
Este tutorial permite que você instale e execute WordPress em um ambiente AWS Cloud9 de desenvolvimento. WordPress é um sistema de gerenciamento de conteúdo (CMS) de código aberto que é amplamente usado para a entrega de conteúdo da web.
**nota**
Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon Elastic Compute Cloud (Amazon EC2). Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/).
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
+ **Você tem uma instância up-to-date EC2 com todos os pacotes de software mais recentes**. Na janela do terminal do AWS Cloud9 IDE, você pode executar `yum update` com a `-y` opção de instalar atualizações sem pedir confirmação. Para examinar as atualizações antes da instalação, você pode omitir essa opção.
```
sudo yum update -y
```
## Visão geral da instalação
A instalação WordPress na instância EC2 do seu ambiente envolve as seguintes etapas:
1. Instalação e configuração do MariaDB Server, que é um banco de dados relacional de código aberto que armazena informações para instalações WordPress
1. Instalação e configuração WordPress, o que inclui a edição do arquivo de `wordpress.conf` configuração
1. Configurando o servidor Apache que hospeda o site WordPress
1. Visualizando o conteúdo WordPress da web hospedado pelo servidor Apache
## Etapa 1: instalar e configurar o MariaDB Server
1. No AWS Cloud9 IDE, escolha **Janela**, **Novo Terminal** e insira os seguintes comandos para instalar e iniciar uma instalação do MariaDB Server:
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. Em seguida, execute o script `mysql_secure_installation` para melhorar a segurança da instalação do MariaDB Server.
Ao fornecer respostas ao script, pressione **Enter** para a primeira pergunta para manter a senha raiz em branco. Pressione**n** para `Set root password?` e **y** para cada uma das opções de segurança restantes.
```
mysql_secure_installation
```
1. Agora, crie uma tabela de banco de dados para armazenar WordPress informações usando o cliente MariaDB.
(Pressione **Enter** quando a senha for solicitada).
```
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. Para encerrar a sessão do cliente MariaDB, execute o comando `exit`.
## Etapa 2: Instalando e configurando WordPress
1. Na janela do terminal do IDE, navegue até o `environment` e, em seguida, crie os diretórios `config` e `wordpress`. Em seguida, execute o comando `touch` para criar um arquivo chamado `wordpress.conf` no diretório `config`:
```
cd /home/ec2-user/environment
mkdir config wordpress
touch config/wordpress.conf
```
1. Use o editor IDE ou o vim para atualizar `wordpress.conf` com as informações de configuração do host que permitem que o servidor Apache forneça conteúdo: WordPress
```
# Ensure that Apache listens on port 80
Listen 8080
DocumentRoot "/var/www/wordpress"
ServerName www.example.org
# Other directives here
```
1. Agora, execute os seguintes comandos para recuperar o arquivo de arquivamento necessário e instalar WordPress:
```
cd /home/ec2-user/environment
wget https://wordpress.org/latest.tar.gz
tar xvf latest.tar.gz
```
1. Execute `touch` para criar um arquivo chamado `wp-config.php` no diretório `environment/wordpress`:
```
touch wordpress/wp-config.php
```
1. Use o vim ou o editor IDE a fim de atualizar `wp-config.php` e substitua os dados da amostra pela sua configuração:
```
// ** 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';
```
## Etapa 3: Configurar o servidor Apache HTTP
1. Na janela do terminal AWS Cloud9 IDE, verifique se você tem o Apache instalado:
```
httpd -v
```
Para instalar o servidor Apache, execute o comando a seguir:
```
sudo yum install -y httpd
```
1. Navegue até o diretório `/etc/httpd/conf.d`, que é o local para os arquivos de configuração de host virtual do Apache. Em seguida, use o comando `ln` para vincular o diretório `wordpress.conf` que você criou anteriormente ao diretório de trabalho atual (`/etc/httpd/conf.d`):
```
cd /etc/httpd/conf.d
sudo ln -s /home/ec2-user/environment/config/wordpress.conf
```
1. Agora navegue até o diretório `/var/www`, que é a pasta raiz padrão para servidores Apache. E use o comando `ln` para vincular o diretório `wordpress` que você criou anteriormente para o diretório de trabalho atual (`/var/www`):
```
cd /var/www
sudo ln -s /home/ec2-user/environment/wordpress
```
1. Execute o comando `chmod` para permitir que o servidor Apache execute conteúdo no subdiretório do `wordpress`:
```
sudo chmod +x /home/ec2-user/
```
1. Agora reinicie o servidor Apache para permitir que ele detecte as novas configurações:
```
sudo service httpd restart
```
## Etapa 4: Pré-visualizar o conteúdo WordPress da web
1. Usando o AWS Cloud9 IDE, crie um novo arquivo chamado `index.html` no seguinte diretório:`environment/wordpress`.
1. Adicione texto formatado em HTML ao `index.html`. Por exemplo:
```
Hello World!
```
1. Na janela **Ambiente**, escolha o arquivo `index.html` e, a seguir, escolha **Visualizar** e **Visualizar a aplicação em execução**.
A página da Web, que exibe a mensagem *Hello World\$1*, aparece na guia de visualização da aplicação. Para exibir o conteúdo da Web em seu navegador preferido, escolha **Pop Out Into a New Window** (Exibir em uma nova janela).
Se você excluir o `index.html` arquivo e atualizar a guia de visualização do aplicativo, a página WordPress de configuração será exibida.
## Gerenciar erros de conteúdo misto
Os navegadores da Web exibem erros mistos de conteúdo para um WordPress site se ele estiver carregando scripts ou conteúdo HTTPS e HTTP ao mesmo tempo. O texto das mensagens de erro depende do navegador da Web que você estiver usando, mas você será informado de que sua conexão com um site é insegura ou não é totalmente segura. E seu navegador da Web bloqueia o acesso ao conteúdo misto.
**Importante**
Por padrão, todas as páginas da Web que você acessa na guia de visualização da aplicação do IDE do AWS Cloud9 usa o protocolo HTTPS automaticamente. Se o URI de uma página apresentar o protocolo `http` inseguro, ele será automaticamente substituído por `https`. Além disso, você não pode acessar o conteúdo inseguro revertendo manualmente o `https` para `http`.
Para obter orientação sobre a implementação de HTTPS em seu site, consulte a [WordPressdocumentação](https://wordpress.org/support/article/https-for-wordpress/).
# Tutorial de Java para AWS Cloud9
**Importante**
Se você estiver usando um ambiente de AWS Cloud9 desenvolvimento apoiado por uma instância do EC2 com 2 GiB ou mais de memória, recomendamos que você ative o suporte aprimorado a Java. Isso fornece acesso a recursos de produtividade como preenchimento de código, linting de erros, ações específicas por contexto e opções de depuração, como pontos de interrupção e passo a passo.
Para obter mais informações, consulte [Suporte aprimorado para desenvolvimento em Java](enhanced-java.md).
Este tutorial permite que você execute alguns códigos Java em um ambiente de AWS Cloud9 desenvolvimento.
Seguir este tutorial e criar este exemplo pode gerar cobranças em sua conta da AWS . Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Pré-requisitos](#sample-java-prerequisites)
+ [Etapa 1: Instalar as ferramentas necessárias](#sample-java-install)
+ [Etapa 2: Adicionar código](#sample-java-code)
+ [Etapa 3: Compilar e executar o código](#sample-java-run)
+ [Etapa 4: configurar para usar o AWS SDK para Java](#sample-java-sdk)
+ [Etapa 5: configurar o gerenciamento de AWS credenciais em seu ambiente](#sample-java-sdk-creds)
+ [Etapa 6: adicionar código AWS SDK](#sample-java-sdk-code)
+ [Etapa 7: criar e executar o código do AWS SDK](#sample-java-sdk-run)
+ [Etapa 8: Limpeza](#sample-java-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar as ferramentas necessárias
Nesta etapa, você instala um conjunto de ferramentas de desenvolvimento Java em seu ambiente de AWS Cloud9 desenvolvimento. Se você já tiver um conjunto de ferramentas de desenvolvimento Java, como o Oracle JDK ou o OpenJDK instalado em seu ambiente, avance para [Etapa 2: Adicionar código](#sample-java-code). Esse exemplo foi desenvolvido com o OpenJDK 8, que você pode instalar em seu ambiente, após concluir o procedimento a seguir.
1. Confirme se o OpenJDK 8 já está instalado. Para fazer isso, em uma sessão de terminal no AWS Cloud9 IDE, execute a versão da linha de comando do executor Java com a **`-version`**opção. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.)
```
java -version
```
Com base na saída do comando anterior, siga um destes procedimentos:
+ Se a saída afirmar que o comando `java` não foi encontrado, vá para a etapa 2 deste procedimento para instalar o OpenJDK 8.
+ Se a saída tiver valores começando com `Java(TM)`, `Java Runtime Environment`, `Java SE`, `J2SE` ou `Java2`, o OpenJDK não está instalado ou não foi definido como o conjunto de ferramentas de desenvolvimento Java padrão. Continue na etapa 2 deste procedimento para instalar o OpenJDK 8 e, em seguida, mude para usar o OpenJDK 8.
+ Se o resultado contiver valores que começam com `java version 1.8` e `OpenJDK`, avance para [Etapa 2: Adicionar código](#sample-java-code). O OpenJDK 8 está instalado corretamente para este exemplo.
+ Se a saída tiver um `java version` menor que `1.8` e valores começando com `OpenJDK`, vá para a etapa 2 deste procedimento para atualizar a versão do OpenJDK instalado para o OpenJDK 8.
1. Verifique se as últimas atualizações de segurança e correções de bugs estão instaladas. Para fazer isso, execute a ferramenta yum (para Amazon Linux) ou a ferramenta apt (para Ubuntu Server) com o comando ** `update` **.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Instale o OpenJDK 8. Para fazer isso, execute a ferramenta yum (para Amazon Linux) ou a ferramenta apt (para Ubuntu Server) com o comando ** `install` **, especificando o pacote OpenJDK 8.
Para Amazon Linux:
```
sudo yum -y install java-1.8.0-openjdk-devel
```
Para Ubuntu Server:
```
sudo apt install -y openjdk-8-jdk
```
Para obter mais informações, consulte [How to download and install prebuilt OpenJDK packages](https://openjdk.org/install/) (Como baixar e instalar pacotes OpenJDK pré-compilados) no site do OpenJDK.
1. Alterne ou atualize o conjunto de ferramentas de desenvolvimento Java padrão para o OpenJDK 8. Para fazer isso, execute o comando ** `update-alternatives` ** com a opção ** `--config` **. Execute esse comando duas vezes para alternar ou atualizar as versões de linha de comando do executor e do compilador Java.
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
Em cada prompt, digite o número da seleção para o OpenJDK 8 (o que contém `java-1.8`).
1. Confirme se as versões de linha de comando do executor e do compilador Java estão usando o OpenJDK 8. Para fazer isso, execute as versões de linha de comando do executor e do compilador Java com a opção `-version`.
```
java -version
javac -version
```
Se o OpenJDK 8 estiver instalado e configurado corretamente, a saída da versão do executor Java terá um valor que começa com `openjdk version 1.8`, e a saída da versão do compilador Java começará com o valor `javac 1.8`.
## Etapa 2: Adicionar código
No AWS Cloud9 IDE, crie um arquivo com o código a seguir e salve o arquivo com o nome`hello.java`. (Para criar um arquivo, na barra de menus, selecione **File** (Arquivo), **New File** (Novo arquivo). Para salvar o arquivo, selecione **File** (Arquivo), **Save** (Salvar).)
```
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));
}
}
```
## Etapa 3: Compilar e executar o código
1. Use a versão de linha de comando do compilador Java para compilar o arquivo `hello.java` em um arquivo `hello.class`. Para fazer isso, usando o terminal no AWS Cloud9 IDE, no mesmo diretório do `hello.java` arquivo, execute o compilador Java, especificando o `hello.java` arquivo.
```
javac hello.java
```
1. Use a versão de linha de comando do executor Java para executar o arquivo `hello.class`. Para fazer isso, no mesmo diretório do arquivo `hello.class`, execute o executor Java, especificando o nome da classe `hello` que foi declarada no arquivo `hello.java`, com dois números inteiros para adicionar (por exemplo, `5` e `9`).
```
java hello 5 9
```
1. Compare a saída.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Etapa 4: configurar para usar o AWS SDK para Java
Você pode aprimorar essa amostra para usar o AWS SDK para Java para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar.
Nesta etapa, você instala o [Apache Maven](https://maven.apache.org/) ou [Gradle](https://gradle.org/) no seu ambiente. Maven e Gradle são sistemas de automação de compilação comuns que podem ser usados com projetos Java. Após instalar Maven ou Gradle, você pode usá-lo para gerar um novo projeto Java. Neste novo projeto, você adiciona uma referência ao AWS SDK para Java. Isso AWS SDK para Java fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do seu código Java.
**Topics**
+ [Configurar com o Maven](#sample-java-sdk-maven)
+ [Configurar com o Gradle](#sample-java-sdk-gradle)
### Configurar com o Maven
1. Instale o Maven em seu ambiente. Para ver se o Maven já está instalado, usando o terminal no AWS Cloud9 IDE, execute o Maven com a **`-version`**opção.
```
mvn -version
```
Se sim, a saída contém o número da versão do Maven. Se o Maven já estiver instalado, passe para a etapa 4 deste procedimento para usar o Maven para gerar um novo projeto Java no seu ambiente.
1. Instale o Maven usando o terminal para executar os comandos a seguir.
Para o Amazon Linux, os seguintes comandos obtêm informações sobre o repositório de pacotes no qual o Maven está armazenado e usam essas informações para instalar o 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
```
Para obter mais informações sobre os comandos anteriores, consulte [Extra Packages for Enterprise Linux (EPEL)](https://docs.fedoraproject.org/en-US/epel/) no site do Wiki Fedora Project.
Para o Ubuntu Server, execute o seguinte comando.
```
sudo apt install -y maven
```
1. Confirme a instalação executando o Maven com a opção ** `-version` **.
```
mvn -version
```
1. Use o Maven para gerar um novo projeto Java. Para fazer isso, use o terminal para executar o comando a seguir no diretório onde você deseja que o Maven gere o projeto (por exemplo, o diretório raiz do seu ambiente).
```
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
O comando anterior cria a seguinte estrutura de diretório para o projeto no seu ambiente.
```
my-app
|- src
| `- main
| `- java
| `- com
| `- mycompany
| `- app
| `-App.java
|- test
| `- java
| `- com
| `- mycompany
| `- app
| `- AppTest.java
`- pom.xml
```
Para obter mais informações sobre a estrutura de diretórios anterior, consulte [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) no site do Apache Maven Project.
1. Modifique o arquivo Project Object Model (POM) para o projeto. Um arquivo POM define configurações do projeto Maven. Para fazer isso, na janela **Ambiente**, abra o arquivo `my-app/pom.xml`. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `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
```
O arquivo POM anterior inclui configurações do projeto que especificam declarações como as seguintes:
+ A configuração `artifactid` de `my-app` define o nome do diretório raiz do projeto, e a configuração `group-id` de `com.mycompany.app` define a estrutura de subdiretório `com/mycompany/app` e a declaração `package` nos arquivos `App.Java` e `AppTest.java`.
+ A configuração `artifactId` de `my-app`, com a configuração `packaging` de `jar`, a configuração `version` de `1.0-SNAPSHOT` e a configuração `descriptorRef` de `jar-with-dependencies` definem o nome do arquivo JAR de saída de `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar`.
+ A seção `plugin` declara que um único JAR, que inclui todas as dependências, será criado.
+ A `dependency` seção com a `groupId` configuração de `com.amazon.aws` e a `artifactId` configuração de `aws-java-sdk` inclui os arquivos da AWS SDK para Java biblioteca. A versão do AWS SDK para Java a ser usada é declarada pela configuração de `version`. Para usar uma versão diferente, substitua esse número de versão.
Avance para [Etapa 5: configurar o gerenciamento de AWS credenciais em seu ambiente](#sample-java-sdk-creds).
### Configurar com o Gradle
1. Instale o Gradle em seu ambiente. Para ver se o Gradle já está instalado, usando o terminal no AWS Cloud9 IDE, execute o Gradle com a **`-version`**opção.
```
gradle -version
```
Se sim, a saída contém o número da versão do Gradle. Se o Gradle já estiver instalado, passe para a etapa 4 deste procedimento para usar o Gradle para gerar um novo projeto Java no seu ambiente.
1. Instale o Gradle usando o terminal para executar os comandos a seguir. Esses comandos instalam e executam a ferramenta SDKMAN\$1 e, em seguida, usam o SDKMAN\$1 para instalar a versão mais recente do Gradle.
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
Para obter mais informações sobre comandos anteriores, consulte [Instalação](https://sdkman.io/install) no site do SDKMAN\$1 e [Instalar com um gerenciador de pacotes](https://gradle.org/install/#with-a-package-manager) no site do Gradle.
1. Confirme a instalação executando o Gradle com a opção ** `-version` **.
```
gradle -version
```
1. Use o Gradle para gerar um novo projeto Java no seu ambiente. Para fazer isso, use o terminal para executar os comandos a seguir para criar um diretório para o projeto e, em seguida, mude para esse diretório.
```
mkdir my-app
cd my-app
```
1. Execute o comando a seguir para que o Gradle gere um novo projeto de aplicação Java no diretório `my-app` em seu ambiente.
```
gradle init --type java-application
```
O comando anterior cria a seguinte estrutura de diretório para o projeto no seu 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. Modifique o `AppTest.java` para o projeto. Se você não fizer isso, o projeto poderá não ser criado ou executado como esperado. Para fazer isso, na janela **Ambiente**, abra o arquivo `my-app/src/test/java/AppTest.java`. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `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. Modifique o arquivo `build.gradle` para o projeto. Um arquivo `build.gradle` define configurações do projeto Gradle. Para fazer isso, na janela **Ambiente**, abra o arquivo `my-app/build.gradle`. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `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'
```
O arquivo `build.gradle` anterior inclui configurações do projeto que especificam declarações como as seguintes:
+ O `io.spring.dependency-management` plug-in é usado para importar a Lista de Materiais (BOM) do AWS SDK para Java Maven para gerenciar AWS SDK para Java dependências do projeto. `classpath`declara a versão a ser usada. Para usar uma versão diferente, substitua esse número de versão.
+ `com.amazonaws:aws-java-sdk-s3` inclui a parte do Amazon S3 dos arquivos da biblioteca do AWS SDK para Java . O `mavenBom` declara a versão a ser usada. Se quiser usar uma versão diferente, substitua esse número de versão.
## Etapa 5: configurar o gerenciamento de AWS credenciais em seu ambiente
Cada vez que você usa o AWS SDK para Java para ligar para um AWS serviço, você deve fornecer um conjunto de AWS credenciais com a chamada. Essas credenciais determinam se ele AWS SDK para Java tem as permissões apropriadas para fazer essa chamada. Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.
Nesta etapa, você armazenará as credenciais no ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
Para mais informações, consulte [Set up AWS Credentials and Region for Development](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) no *Guia do desenvolvedor do AWS SDK para Java *.
## Etapa 6: adicionar código AWS SDK
Nesta etapa, adicione código para interagir com o Amazon S3 para criar um bucket, listar os buckets disponíveis e excluir o bucket que você acabou de criar.
Na janela **Environment (Ambiente)**, abra o arquivo `my-app/src/main/java/com/mycompany/app/App.java` para o Maven ou o arquivo `my-app/src/main/java/App.java` para o Gradle. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `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());
}
}
}
```
## Etapa 7: criar e executar o código do AWS SDK
Para executar o código da etapa anterior, execute os seguintes comandos do terminal. Esses comandos usam Maven ou Gradle para criar um arquivo JAR executável para o projeto e, em seguida, usam o executor Java para executar o JAR. O JAR é executado com o nome do bucket a ser criado no Amazon S3 (por exemplo,`my-test-bucket`) e o ID da AWS região para criar o bucket como entrada (por exemplo,`us-east-2`).
Para o Maven, execute os comandos a seguir.
```
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
```
Para o Gradle, execute os comandos a seguir.
```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```
Compare os resultados com a seguinte saída.
```
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:
```
## Etapa 8: Limpeza
Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# Tutorial de C\$1\$1 para AWS Cloud9
Este tutorial permite que você execute código C\$1\$1 em um ambiente de AWS Cloud9 desenvolvimento. O código também usa recursos fornecidos pelo [AWS SDK para C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/welcome.html), uma biblioteca modular, multiplataforma e de código aberto que você pode usar para se conectar à Amazon Web Services.
Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Pré-requisitos](#sample-cplusplus-prereqs)
+ [Etapa 1: Instalar g\$1\$1 e pacotes de desenvolvimento necessários](#sample-cplusplus-install)
+ [Etapa 2: instalar CMake](#install-cmake)
+ [Etapa 3: Obter e compilar o SDK for C\$1\$1](#install-cmake)
+ [Etapa 4: Criar arquivos C\$1\$1 e CMake Listas](#sample-cplusplus-sdk-code)
+ [Etapa 5: Compilar e executar o código C\$1\$1](#build-and-run-cpp)
+ [Etapa 6: limpar](#sample-cplusplus-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar g\$1\$1 e pacotes de desenvolvimento necessários
Para criar e executar uma aplicação C\$1\$1, você precisa de um utilitário como o `g++`, que é um compilador C\$1\$1 fornecido pelo [GNU Complier Collection (GCC)](https://gcc.gnu.org/).
Você também precisa adicionar arquivos de cabeçalho (pacotes `-dev`) para `libcurl`, `libopenssl`, `libuuid`, `zlib` e, opcionalmente, `libpulse` para suporte do Amazon Polly.
O processo de instalação das ferramentas de desenvolvimento varia um pouco, dependendo se você está usando uma instância do Amazon Linux/Amazon Linux 2 ou uma instância do Ubuntu.
------
#### [ Amazon Linux-based systems ]
Você pode verificar se você já `gcc` instalou executando o seguinte comando no AWS Cloud9 terminal:
```
g++ --version
```
Se o `g++` não estiver instalado, você pode instalá-lo facilmente como parte do grupo de pacotes chamado "Development Tools" (Ferramentas de desenvolvimento). Essas ferramentas são adicionadas a uma instância com o comando `yum groupinstall`:
```
sudo yum groupinstall "Development Tools"
```
Execute `g++ --version` novamente para confirmar se o compilador foi instalado.
Agora instale os pacotes para as bibliotecas necessárias usando o gerenciador de pacotes do sistema:
```
sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
```
------
#### [ Ubuntu-based systems ]
Você pode verificar se você já `gcc` instalou executando o seguinte comando no AWS Cloud9 terminal:
```
g++ --version
```
Se o gcc não estiver instalado, você poderá instalá-lo em um sistema baseado em Ubuntu, executando os seguintes comandos:
```
sudo apt update
sudo apt install build-essential
sudo apt-get install manpages-dev
```
Execute `g++ --version` novamente para confirmar se o compilador foi instalado.
Agora instale os pacotes para as bibliotecas necessárias usando o gerenciador de pacotes do sistema:
```
sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
```
------
## Etapa 2: instalar CMake
Você precisa instalar a ferramenta `cmake`, que automatiza o processo de construção de arquivos executáveis a partir do código-fonte.
1. Na janela do terminal do IDE, execute o seguinte comando para obter o arquivamento necessário:
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
1. Extraia os arquivos do arquivamento e navegue até o diretório que contém os arquivos descompactados:
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
1. Em seguida, execute um script bootstrap e instale `cmake`, executando os seguintes comandos:
```
./bootstrap
make
sudo make install
```
1. Confirme se você instalou a ferramenta executando o seguinte comando:
```
cmake --version
```
## Etapa 3: Obter e compilar o SDK for C\$1\$1
Para configurar o AWS SDK para C\$1\$1, você mesmo pode criar o SDK diretamente da fonte ou baixar as bibliotecas usando um gerenciador de pacotes. Você pode encontrar detalhes sobre as opções disponíveis em [Introdução ao uso do AWS SDK para](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html) C\$1\$1 *AWS SDK para C\$1\$1 no* Guia do desenvolvedor.
Este exemplo demonstra o uso do `git` para clonar o código-fonte do SDK e `cmake` para compilar o SDK for C\$1\$1.
1. Clone o repositório remoto e obtenha todos os submódulos do Git recursivamente para o ambiente do AWS Cloud9 , executando o seguinte comando no terminal:
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. Navegue até o novo `aws-sdk-cpp` diretório, crie um subdiretório para compilar o AWS SDK para C\$1\$1 e, em seguida, navegue até ele:
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**nota**
Para economizar tempo, essa etapa cria apenas a parte do Amazon S3 do AWS SDK para C\$1\$1. Se você quiser compilar o SDK completo, omita a propriedade `-DBUILD_ONLY=s3` do comando `cmake`.
A criação do SDK for C\$1\$1 completo pode levar mais de uma hora, dependendo dos recursos de computação disponíveis para a instância do Amazon EC2 ou para o próprio servidor.
Use o `cmake` para compilar a parte do Amazon S3 do SDK for C\$1\$1 no `sdk_build`executando o seguinte comando:
```
cmake .. -DBUILD_ONLY=s3
```
1. Agora, execute o comando `make install` para que o SDK integrado possa ser acessado:
```
sudo make install
cd ..
```
## Etapa 4: Criar arquivos C\$1\$1 e CMake Listas
Nesta etapa, você criará um arquivo `C++` que permite que os usuários do projeto interajam com buckets do Amazon S3.
Você também cria um arquivo `CMakeLists.txt` que fornece instruções que são usadas pelo `cmake` para criar sua biblioteca C\$1\$1.
1. No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o nome `s3-demo.cpp` na raiz (`/`) do seu 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. Crie um segundo arquivo com esse conteúdo e salve-o com o nome `CMakeLists.txt` na raiz (`/`) do seu ambiente. Esse arquivo permite compilar o código em um arquivo executável.
```
# 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})
```
## Etapa 5: Compilar e executar o código C\$1\$1
1. No diretório raiz do ambiente no qual você salvou a `s3-demo.cpp` e o `CMakeLists.txt`, execute `cmake` para compilar o projeto:
```
cmake .
make
```
1. Agora você pode executar o programa da linha de comando. No comando a seguir, substitua `my-unique-bucket-name` por um nome exclusivo para o bucket do Amazon S3 e, se necessário, substitua `us-east-1` pelo identificador de outra região da AWS onde você deseja criar um bucket.
```
./s3-demo my-unique-bucket-name us-east-1
```
Se o programa for executado com êxito, você verá um resultado semelhante a este:
```
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.
```
## Etapa 6: limpar
Para evitar cobranças contínuas em sua AWS conta depois que você terminar de usar essa amostra, exclua o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# Tutorial de Python para AWS Cloud9
Este tutorial mostra como executar o código Python em um ambiente de AWS Cloud9 desenvolvimento.
Seguir este tutorial pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon Elastic Compute Cloud (Amazon EC2) e o Amazon Simple Storage Service (Amazon S3). Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Pré-requisitos](#sample-python-prereqs)
+ [Etapa 1: Instalar o Python](#sample-python-install)
+ [Etapa 2: Adicionar código](#sample-python-code)
+ [Etapa 3: Executar o código](#sample-python-run)
+ [Etapa 4: instalar e configurar o AWS SDK para Python (Boto3)](#sample-python-sdk)
+ [Etapa 5: adicionar código AWS SDK](#sample-python-sdk-code)
+ [Etapa 6: executar o código do AWS SDK](#sample-python-sdk-run)
+ [Etapa 7: limpar](#sample-python-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se atende aos requisitos a seguir.
+ **Você tem um ambiente de desenvolvimento AWS Cloud9 EC2**
Este tutorial pressupõe que você já tem um ambiente EC2, e que esse ambiente esteja conectado a uma instância do Amazon EC2, executada no Amazon Linux ou Ubuntu Server. Para mais detalhes, consulte [Criando um EC2 ambiente](create-environment-main.md).
Se você tiver um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções deste tutorial.
+ **Você abriu o AWS Cloud9 IDE para esse ambiente**
Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para mais detalhes, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar o Python
1. Em uma sessão de terminal no AWS Cloud9 IDE, confirme se o Python já está instalado executando o **`python --version`**comando. (Para iniciar uma nova sessão de terminal, na barra de menus, escolha **Window (Janela)**, **New Terminal (Novo terminal)**.) Se o Python estiver instalado, avance para [Etapa 2: Adicionar código](#sample-python-code).
1. Execute o comando ** `yum update`** para Amazon Linux ou o comando **`apt update`** para Ubuntu Server para ajudar a garantir que as atualizações de segurança e correções de bug mais recentes estejam instaladas.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Instale o Python executando o comando ** `install` **.
Para Amazon Linux:
```
sudo yum -y install python3
```
Para Ubuntu Server:
```
sudo apt-get install python3
```
## Etapa 2: Adicionar código
No AWS Cloud9 IDE, crie um arquivo com o conteúdo a seguir e salve o arquivo com o nome`hello.py`. (Para criar um arquivo, na barra de menus, selecione **File** (Arquivo), **New File** (Novo arquivo). Para salvar o arquivo, selecione **File** (Arquivo), **Save** (Salvar).
```
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))
```
## Etapa 3: Executar o código
1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[New] - Stopped ([Novo] - Parado)**, insira `hello.py 5 9` para **Command (Comando)**. No código, `5` representa `sys.argv[1]` e `9` representa `sys.argv[2]`.
1. Selecione **Run (Executar)** e compare sua saída.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
1. Por padrão, seleciona AWS Cloud9 automaticamente um executor para seu código. Para alterar o executor, escolha **Runner (Executor)** e selecione **Python 2** ou **Python 3**.
**nota**
Você pode criar executores personalizados para versões específicas do Python. Para obter detalhes, consulte [Criar um compilador ou executor](build-run-debug.md#build-run-debug-create-builder-runner).
## Etapa 4: instalar e configurar o AWS SDK para Python (Boto3)
AWS SDK para Python (Boto3) Isso permite que você use o código Python para interagir com AWS serviços como o Amazon S3. Por exemplo, é possível usar o SDK para criar um bucket do Amazon S3, listar os buckets disponíveis e excluir o bucket que você acabou de criar.
### Instalar o pip
No AWS Cloud9 IDE, confirme `pip` se a versão ativa do Python já está instalada executando o **`python -m pip --version`**comando. Se o `pip` estiver instalado, avance para a próxima seção.
Para instalar o `pip`, execute os comandos a seguir. Como o sudo está em um ambiente diferente do seu usuário, você deve especificar a versão do Python a ser usada caso ela seja diferente da versão atual com alias.
```
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.
```
Para obter mais informações, consulte [Instalação](https://pip.pypa.io/en/stable/installing/) no site do `pip`.
### Instale o AWS SDK para Python (Boto3)
Depois de instalar`pip`, instale o AWS SDK para Python (Boto3) executando o **`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.
```
Para obter mais informações, consulte a seção "Installation" (Instalação) de [Quickstart (Início rápido)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) em AWS SDK para Python (Boto3).
### Configurar o gerenciamento de credenciais no ambiente
Cada vez que você usa o AWS SDK para Python (Boto3) para chamar um AWS serviço, você deve fornecer um conjunto de credenciais com a chamada. Essas credenciais determinam se o SDK tem as permissões necessárias para fazer a chamada. Se as credenciais não cobrirem as permissões necessárias, a chamada falhará.
Para armazenar suas credenciais no ambiente, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
Para obter informações adicionais, consulte [Credentials (Credenciais)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html) em AWS SDK para Python (Boto3).
## Etapa 5: adicionar código AWS SDK
Adicione o código que usa o Amazon S3 para criar um bucket, liste seus buckets disponíveis e, opcionalmente, exclua o bucket que você acabou de criar.
No AWS Cloud9 IDE, crie um arquivo com o conteúdo a seguir e salve o arquivo com o 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()
```
## Etapa 6: executar o código do AWS SDK
1. Na barra de menus, selecione **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Em **Command**`s3.py my-test-bucket us-west-2`, insira, onde `my-test-bucket` está o nome do bucket a ser criado e `us-west-2` é o ID da AWS região em que seu bucket foi criado. Por padrão, seu bucket é excluído antes que o script seja encerrado. Para manter seu bucket, adicione `--keep_bucket` ao seu comando. Para obter uma lista de AWS regiões IDs, consulte [Amazon Simple Storage Service Endpoints and Quotas](https://docs.aws.amazon.com/general/latest/gr/s3.html) no. *Referência geral da AWS*
**nota**
Os nomes dos buckets do Amazon S3 devem ser exclusivos em toda a sua conta, AWS não apenas em sua conta. AWS
1. Selecione **Executar** e compare sua saída.
```
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
```
## Etapa 7: limpar
Para evitar cobranças contínuas AWS em sua conta depois de concluir este tutorial, exclua o AWS Cloud9 ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# Tutorial.NET para AWS Cloud9
Este tutorial permite que você execute alguns códigos.NET em um ambiente de AWS Cloud9 desenvolvimento.
Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Pré-requisitos](#sample-dotnetcore-prereqs)
+ [Etapa 1: Instalar as ferramentas necessárias](#sample-dotnetcore-setup)
+ [Etapa 2 (Opcional): Instalar a extensão da CLI .NET para funções do Lambda](#sample-dotnetcore-lambda)
+ [Etapa 3: Criar um projeto de aplicação do console do .NET](#sample-dotnetcore-app)
+ [Etapa 4: Adicionar código](#sample-dotnetcore-code)
+ [Etapa 5: Compilar e executar o código](#sample-dotnetcore-run)
+ [Etapa 6: Criar e configurar um projeto de aplicativo de console do.NET que usa o AWS SDK para .NET](#sample-dotnetcore-sdk)
+ [Etapa 7: adicionar código AWS SDK](#sample-dotnetcore-sdk-code)
+ [Etapa 8: criar e executar o código do AWS SDK](#sample-dotnetcore-sdk-run)
+ [Etapa 9: Limpar](#sample-dotnetcore-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar as ferramentas necessárias
Nesta etapa, você instalará o SDK do .NET em seu ambiente, o que é necessário para executar esse exemplo.
1. Confirme se a versão mais recente do SDK do .NET já está instalada em seu ambiente. Para fazer isso, em uma sessão de terminal no AWS Cloud9 IDE, execute a interface de linha de comando (CLI) .NET Core com a **`--version`**opção.
```
dotnet --version
```
Se a versão das ferramentas de linha de comando do .NET for exibida, e a versão for 2.0 ou superior, avance para [Etapa 3: Criar um projeto de aplicação do console do .NET](#sample-dotnetcore-app). Se a versão for inferior a 2.0, ou se um erro como `bash: dotnet: command not found` for exibido, continue a instalar o SDK do .NET.
1. Para o Amazon Linux, em uma sessão de terminal no AWS Cloud9 IDE, execute os seguintes comandos para ajudar a garantir que as atualizações de segurança e correções de erros mais recentes sejam instaladas e para instalar um `libunwind` pacote que o SDK.NET precisa. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela, Novo terminal**.)
```
sudo yum -y update
sudo yum -y install libunwind
```
Para o Ubuntu Server, em uma sessão de terminal no AWS Cloud9 IDE, execute o comando a seguir para ajudar a garantir que as atualizações de segurança e correções de erros mais recentes estejam instaladas. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela, Novo terminal**.)
```
sudo apt -y update
```
1. Baixe o script do instalador do SDK do .NET em seu ambiente executando o comando a seguir.
```
wget https://dot.net/v1/dotnet-install.sh
```
1. Torne o script do instalador executável pelo usuário atual executando o comando a seguir.
```
sudo chmod u=rx dotnet-install.sh
```
1. Execute o script do instalador, que baixa e instala o SDK do .NET, executando o comando a seguir.
```
./dotnet-install.sh -c Current
```
1. Adicione o SDK do .NET ao `PATH`. Para fazer isso, no perfil de shell do ambiente (por exemplo, o arquivo `.bashrc`), adicione o subdiretório `$HOME/.dotnet` à variável `PATH` para o ambiente, da seguinte forma:
1. Abra o arquivo `.bashrc` para edição usando o comando ** `vi`**.
```
vi ~/.bashrc
```
1. Para o Amazon Linux, usando a seta para baixo ou a tecla `j`, vá até a linha que começa com `export PATH`.
Para Ubuntu Server, mova para a última linha do arquivo digitando `G`.
1. Usando a seta para a direita ou a tecla `$`, mova para o final da linha.
1. Alterne para modo de inserção pressionando a tecla `i`. (`-- INSERT ---` aparecerá no final da tela.)
1. Para o Amazon Linux, adicione o subdiretório `$HOME/.dotnet` à variável ** `PATH` **, digitando `:$HOME/.dotnet`. Certifique-se de incluir o caractere de dois pontos (`:`). A linha agora deve ser semelhante à que vem a seguir.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
Para o Ubuntu Server, pressione a tecla de seta para a direita e pressione `Enter` duas vezes e digite a seguinte linha no final do arquivo.
```
export PATH=$HOME/.dotnet:$PATH
```
1. Salve o arquivo. Para fazer isso, pressione a tecla `Esc` (`-- INSERT ---` desaparecerá do final da tela), digite `:wq` (para gravar e, em seguida, encerrar o arquivo) e, em seguida, pressione `Enter`.
1. Carregue o SDK do .NET após obter o arquivo `.bashrc`.
```
. ~/.bashrc
```
1. Confirme o SDK do .NET está carregado executando a CLI do .NET com a opção ** `--help` **.
```
dotnet --help
```
Se for bem-sucedido, o número da versão do SDK do .NET será exibido, com mais informações de uso.
1. Se você não quiser mais manter o script do instalador do SDK do .NET em seu ambiente, exclua-o da seguinte forma:
```
rm dotnet-install.sh
```
## Etapa 2 (Opcional): Instalar a extensão da CLI .NET para funções do Lambda
Embora não seja necessário para este tutorial, você pode implantar AWS Lambda funções e AWS Serverless Application Model aplicativos usando a CLI do.NET se também instalar o `Amazon.Lambda.Tools` pacote.
1. Para instalar esse pacote, execute o seguinte comando:
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Agora defina as variáveis de ambiente `PATH` e `DOTNET_ROOT` apontando para a ferramenta do Lambda instalada. No arquivo `.bashrc`, localize a seção `export PATH` e edite-a para que fique semelhante à seguinte (consulte a Etapa 1 para obter detalhes sobre como editar esse arquivo):
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```
## Etapa 3: Criar um projeto de aplicação do console do .NET
Nesta etapa, use o .NET para criar um projeto chamado `hello`. Esse projeto contém todos os arquivos que o .NET precisa para executar uma aplicação simples no terminal do IDE. O código do aplicativo é gravado em C\$1.
Crie um projeto de aplicação do console do .NET. Para fazer isso, execute a CLI do .NET com o comando ** `new` **, especificando o modelo de projeto de aplicação do console e a linguagem de programação a ser usada (neste exemplo, C\$1).
A opção `-n` indica que o projeto tem saída para um novo diretório, `hello`. Em seguida, navegamos até o diretório.
```
dotnet new console -lang C# -n hello
cd hello
```
O comando anterior adiciona um subdiretório chamado `obj` com vários arquivos, e alguns outros arquivos independentes, ao diretório `hello`. Observe os dois arquivos de chave a seguir:
+ O arquivo `hello/hello.csproj` contém informações sobre o projeto de aplicativo do console.
+ O arquivo `hello/Program.cs` contém o código do aplicativo a ser executado.
## Etapa 4: Adicionar código
Nesta etapa, você adiciona algum código ao aplicativo.
Na janela **Ambiente** do AWS Cloud9 IDE, abra o `hello/Program.cs` arquivo.
No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `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);
}
}
}
```
## Etapa 5: Compilar e executar o código
Nesta etapa, você criará o projeto e suas dependências em um conjunto de arquivos binários, incluindo um arquivo executável da aplicação. Em seguida, você executa a aplicação.
1. No IDE, crie um construtor para o .NET da seguinte forma:
1. Na barra de menus, selecione **Run (Executar), Build System (Sistema de compilação), New Build System (Novo sistema de compilação)**.
1. Na guia **My Builder.build (Meu Builder.build)**, substitua o conteúdo da guia pelo código a seguir.
```
{
"cmd" : ["dotnet", "build"],
"info" : "Building..."
}
```
1. Selecione **Arquivo, Salvar como**.
1. Para **Nome do arquivo**, digite `.NET.build`.
1. Para **Pasta**, digite `/.c9/builders`.
1. Escolha **Salvar**.
1. Com o conteúdo do arquivo `Program.cs` exibido no editor, selecione **Executar, Sistema de compilação, .NET**. Em seguida, selecione **Run, Build (Executar, Compilar)**.
Esse compilador adiciona um subdiretório chamado `bin` e adiciona um subdiretório chamado `Debug` ao subdiretório `hello/obj`. Observe os três arquivos de chave a seguir.
+ O arquivo `hello/bin/Debug/netcoreapp3.1/hello.dll` é o arquivo executável do aplicativo.
+ O arquivo `hello/bin/Debug/netcoreapp3.1/hello.deps.json` lista as dependências do aplicativo.
+ O arquivo `hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json` especifica o tempo de execução compartilhado e sua versão para o aplicativo.
**nota**
O nome da pasta, `netcoreapp3.1`, reflete a versão do SDK do .NET usado neste exemplo. Você poderá ver um número diferente no nome da pasta, dependendo da versão instalada.
1. Crie um executor para o .NET da seguinte forma.
1. Na barra de menus, escolha **Run (Executar), Run With (Executar com), New Runner (Novo executor)**.
1. Na guia **My Runner.run (Meu Runner.run)**, substitua o conteúdo da guia pelo código a seguir.
```
{
"cmd" : ["dotnet", "run", "$args"],
"working_dir": "$file_path",
"info" : "Running..."
}
```
1. Selecione **Arquivo, Salvar como**.
1. Para **Nome do arquivo**, digite `.NET.run`.
1. Para **Pasta**, digite `/.c9/runners`.
1. Escolha **Salvar**.
1. Execute o aplicativo com dois números inteiros a serem adicionados (por exemplo, `5` e `9`) da seguinte forma.
1. Com o conteúdo do arquivo `Program.cs` exibido no editor, escolha **Run (Executar), Run Configurations (Configurações de execução), New Run Configuration (Nova configuração de execução)**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **.NET**.
1. Na caixa **Command (Comando)**, digite `hello 5 9`.
1. Escolha **Executar**.
Por padrão, esse executor instrui o .NET a executar o arquivo `hello.dll` no diretório `hello/bin/Debug/netcoreapp3.1`.
Compare o resultado com o seguinte.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Etapa 6: Criar e configurar um projeto de aplicativo de console do.NET que usa o AWS SDK para .NET
Você pode aprimorar essa amostra para usar o AWS SDK para .NET para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar.
Neste novo projeto, você adiciona uma referência ao AWS SDK para .NET. AWS SDK para .NET Ele fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do seu código.NET. Em seguida, você configura o gerenciamento de AWS credenciais em seu ambiente. Eles AWS SDK para .NET precisam dessas credenciais para interagir com os AWS serviços.
### Para criar o projeto do
1. Crie um projeto de aplicação do console do .NET. Para fazer isso, execute a CLI do .NET com o comando **`new`**, especificando o modelo de projeto de aplicação do console e a linguagem de programação a ser usada.
A opção `-n` indica que o projeto tem saída para um novo diretório, `s3`. Em seguida, navegamos até o diretório.
```
dotnet new console -lang C# -n s3
cd s3
```
1. Adicione uma referência de projeto ao pacote do Amazon S3 no AWS SDK para .NET. Para fazer isso, execute a CLI do.NET com o **`add package`**comando, especificando o nome do pacote Amazon S3 em. NuGet (NuGetdefine como os pacotes do.NET são criados, hospedados e consumidos e fornece as ferramentas para cada uma dessas funções.)
```
dotnet add package AWSSDK.S3
```
Quando você adiciona uma referência de projeto ao pacote Amazon S3, NuGet também adiciona uma referência de projeto ao resto do. AWS SDK para .NET
**nota**
Para os nomes e versões de outros pacotes AWS relacionados em NuGet, consulte [NuGetpacotes marcados com aws-sdk no site](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22). NuGet
### Para configurar o gerenciamento de AWS credenciais
Cada vez que você usa o AWS SDK para .NET para chamar um AWS serviço, você deve fornecer um conjunto de AWS credenciais com a chamada. Essas credenciais determinam se ele AWS SDK para .NET tem as permissões apropriadas para fazer essa chamada. Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.
Para armazenar suas credenciais no ambiente, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
Para obter informações adicionais, consulte [Configuração de AWS credenciais](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html) no Guia do *AWS SDK para .NET desenvolvedor*.
## Etapa 7: adicionar código AWS SDK
Nesta etapa, você adicionará código para interagir com o Amazon S3 para criar um bucket, excluir o bucket que acabou de criar e listar os buckets disponíveis.
Na janela **Ambiente** do AWS Cloud9 IDE, abra o `s3/Program.cs` arquivo. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `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);
}
}
}
}
}
```
## Etapa 8: criar e executar o código do AWS SDK
Nesta etapa, você criará o projeto e suas dependências em um conjunto de arquivos binários, incluindo um arquivo executável da aplicação. Em seguida, você executa a aplicação.
1. Crie o projeto. Para fazer isso, com o conteúdo do arquivo `s3/Program.cs` exibido no editor, na barra de menus, selecione **Run (Executar), Build (Compilação)**.
1. Execute a aplicação com o nome do bucket do Amazon S3 a ser criado e o ID da região da AWS na qual criar o bucket (por exemplo, `my-test-bucket` e `us-east-2`) da seguinte forma:
1. Com o conteúdo do arquivo `s3/Program.cs` ainda exibido no editor, escolha **Run (Executar), Run Configurations (Configurações de execução), New Run Configuration (Nova configuração de execução)**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **.NET**.
1. Na caixa **Comando**, digite o nome do aplicativo, o nome do bucket do Amazon S3 a ser criado e o ID da AWS região na qual criar o bucket (por exemplo,`s3 my-test-bucket us-east-2`).
1. Escolha **Executar**.
Por padrão, esse executor instrui o .NET a executar o arquivo `s3.dll` no diretório `s3/bin/Debug/netcoreapp3.1`.
Compare os resultados com a seguinte saída.
```
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:
```
## Etapa 9: Limpar
Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# Tutorial do Node.js para AWS Cloud9
Este tutorial permite que você execute alguns scripts do Node.js em um ambiente de AWS Cloud9 desenvolvimento.
Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Amazon EC2 Pricing](https://aws.amazon.com/ec2/pricing/) e [Amazon S3](https://aws.amazon.com/s3/pricing/) Pricing.
**Topics**
+ [Pré-requisitos](#sample-nodejs-prereqs)
+ [Etapa 1: Instalar as ferramentas necessárias](#sample-nodejs-install)
+ [Etapa 2: Adicionar código](#sample-nodejs-code)
+ [Etapa 3: Executar o código](#sample-nodejs-run)
+ [Etapa 4: instalar e configurar o AWS SDK para JavaScript no Node.js](#sample-nodejs-sdk)
+ [Etapa 5: adicionar código AWS SDK](#sample-nodejs-sdk-code)
+ [Etapa 6: executar o código do AWS SDK](#sample-nodejs-sdk-run)
+ [Etapa 7: limpar](#sample-nodejs-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de AWS Cloud9 EC2 desenvolvimento existente.** Este exemplo pressupõe que você já tenha um EC2 ambiente conectado a uma EC2 instância da Amazon que executa o Amazon Linux ou Ubuntu Servidor. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar as ferramentas necessárias
Nesta etapa, instale o Node.js, necessário para executar esse exemplo.
1. Em uma sessão de terminal no AWS Cloud9 IDE, confirme se o Node.js já está instalado executando o **`node --version`**comando. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.) Se sim, a saída contém o número da versão da Node.js. Se o Node.js estiver instalado, avance para [Etapa 2: Adicionar código](#sample-nodejs-code).
1. Execute o comando ** `yum update` ** para Amazon Linux ou o comando ** `apt update` ** para Ubuntu Server a fim de ajudar a garantir que as atualizações de segurança e correções de bug mais recentes sejam instaladas.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Para instalar o Node.js, comece executando esse comando para baixar o Node Version Manager (nvm). (nvm é um script de shell Bash simples que é útil para instalar e gerenciar versões do Node.js. Para obter mais informações, consulte [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md) no GitHub site.)
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
```
1. Para começar a usar o nvm, feche a sessão de terminal e inicie-a novamente ou extraia o arquivo `~/.bashrc` que contém os comandos para carregar o nvm.
```
. ~/.bashrc
```
1. Execute esse comando para instalar o Node.js 16 no Amazon Linux 2, Amazon Linux 1 e Ubuntu 18.04. As instâncias do Amazon Linux 1 e do Ubuntu 18.04 só são compatíveis com o Node.js até a v16.
```
nvm install 16
```
Execute este comando para instalar a versão mais recente do Node.js no Amazon Linux 2023 e no Ubuntu 22.04:
```
nvm install --lts && nvm alias default lts/*
```
**nota**
A AWS Cloud9 imagem AL2 023 mais recente tem o Node.js 20 instalado e a AWS Cloud9 imagem mais recente do Amazon Linux 2 tem o Node.js 18 instalado. Se você quiser instalar o Node.js 18 no Amazon Linux 2 AWS Cloud9 manualmente, execute o seguinte comando no terminal do 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
```
## Etapa 2: Adicionar código
No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o nome`hello.js`. (Para criar um arquivo, na barra de menus, selecione **File** (Arquivo), **New File** (Novo arquivo). Para salvar o arquivo, selecione **File** (Arquivo), **Save** (Salvar).)
```
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 + '.');
```
## Etapa 3: Executar o código
1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Node.js**.
1. Em **Comando**, digite `hello.js 5 9`. No código, `5` representa `process.argv[2]`, e `9` representa `process.argv[3]`. (`process.argv[0]` representa o nome do tempo de execução (`node`) e `process.argv[1]` representa o nome do arquivo (`hello.js`).)
1. Selecione o botão **Executar** e compare a sua saída.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Saída Node.js após executar o código no AWS Cloud9 IDE\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## Etapa 4: instalar e configurar o AWS SDK para JavaScript no Node.js
Ao executar scripts do Node.js AWS Cloud9, você pode escolher entre o AWS SDK para a JavaScript versão 3 (V3) e o AWS SDK mais antigo para a JavaScript versão 2 (V2). Assim como na V2, a V3 permite que você trabalhe facilmente com a Amazon Web Services, mas foi incorporada TypeScript e adiciona vários recursos frequentemente solicitados, como pacotes modularizados.
------
#### [ AWS SDK for JavaScript (V3) ]
Você pode aprimorar essa amostra para usar o AWS SDK JavaScript em Node.js para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar.
Nesta etapa, você instala e configura o módulo cliente do serviço Amazon S3 do AWS SDK para JavaScript o Node.js, que fornece uma maneira conveniente de interagir com o AWS serviço Amazon S3 a partir do seu código. JavaScript
Se você quiser usar outros AWS serviços, precisará instalá-los separadamente. Para obter mais informações sobre a instalação de AWS módulos, consulte [o *Guia do AWS desenvolvedor (V3)*](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/working-with-services). Para obter informações sobre como começar a usar o Node.js e o AWS SDK for JavaScript (V3), consulte [Introdução ao Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure) no *Guia do AWS SDK para JavaScript desenvolvedores (*V3).
Depois de instalar o AWS SDK para JavaScript no Node.js, você deve configurar o gerenciamento de credenciais em seu ambiente. O AWS SDK do Node.js precisa dessas credenciais para interagir com AWS os serviços. JavaScript
**Para instalar o AWS SDK JavaScript em Node.js**
Use o npm para executar o comando ** `install` **.
```
npm install @aws-sdk/client-s3
```
Para obter mais informações, consulte [Instalando o SDK JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html#installing-jssdk) no *Guia do AWS SDK para JavaScript desenvolvedor*.
**Como configurar o gerenciamento de credenciais no ambiente**
Sempre que você usa o AWS SDK do Node.js para JavaScript chamar um AWS serviço, você deve fornecer um conjunto de credenciais com a chamada. Essas credenciais determinam se o AWS SDK do Node.js tem as permissões apropriadas para fazer essa chamada. JavaScript Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.
Nesta etapa, você armazenará as credenciais no ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
Para obter mais informações, consulte [Setting Credentials in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) (Definir credenciais no Node.js) no *Manual do desenvolvedor do AWS SDK para JavaScript *.
------
#### [ AWS SDK for JavaScript (V2) ]
Você pode aprimorar essa amostra para usar o AWS SDK JavaScript em Node.js para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar.
Nesta etapa, você instala e configura o AWS SDK JavaScript no Node.js, que fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do JavaScript seu código. Depois de instalar o AWS SDK para JavaScript no Node.js, você deve configurar o gerenciamento de credenciais em seu ambiente. O AWS SDK do Node.js precisa dessas credenciais para interagir com AWS os serviços. JavaScript
**Para instalar o AWS SDK JavaScript em Node.js**
Use o npm para executar o comando ** `install` **.
```
npm install aws-sdk
```
Para obter mais informações, consulte [Instalando o SDK JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) no *Guia do AWS SDK para JavaScript desenvolvedor*.
**Como configurar o gerenciamento de credenciais no ambiente**
Sempre que você usa o AWS SDK do Node.js para JavaScript chamar um AWS serviço, você deve fornecer um conjunto de credenciais com a chamada. Essas credenciais determinam se o AWS SDK do Node.js tem as permissões apropriadas para fazer essa chamada. JavaScript Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.
Nesta etapa, você armazenará as credenciais no ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
Para obter mais informações, consulte [Setting Credentials in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) (Definir credenciais no Node.js) no *Manual do desenvolvedor do AWS SDK para JavaScript *.
------
## Etapa 5: adicionar código AWS SDK
------
#### [ AWS SDK for JavaScript (V3) ]
Nesta etapa, adicione mais código, dessa vez para interagir com o Amazon S3 para criar um bucket, listar os buckets disponíveis e, excluir o bucket que você acabou de criar. Esse código será executado mais tarde.
No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o 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) ]
Nesta etapa, adicione mais código, dessa vez para interagir com o Amazon S3 para criar um bucket, listar os buckets disponíveis e, excluir o bucket que você acabou de criar. Esse código será executado mais tarde.
No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o 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,
]);
```
------
## Etapa 6: executar o código do AWS SDK
1. Habilite o código para chamar operações do Amazon S3 de forma assíncrona usando o npm para executar o comando ** `install` **.
```
npm install async
```
1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Node.js**.
1. Se você estiver usando o AWS SDK para JavaScript (V3), para o tipo de **comando**. `s3.js` Se você estiver usando o AWS SDK para Javascript (v2), para o tipo **Command**`s3.js my-test-bucket us-east-2`, onde `my-test-bucket` está o nome do bucket que você deseja criar e depois excluir, e `us-east-2` é o ID da AWS região na qual você deseja criar o bucket. Para obter mais informações IDs, consulte [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) no. *Referência geral da Amazon Web Services*
**nota**
Os nomes dos buckets do Amazon S3 devem ser exclusivos em toda a sua conta, AWS não apenas em sua conta. AWS
1. Selecione o botão **Executar** e compare a sua saída.
```
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:
```
## Etapa 7: limpar
Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para obter instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# Tutorial de PHP para AWS Cloud9
Este tutorial permite que você execute alguns scripts PHP em um ambiente de AWS Cloud9 desenvolvimento.
Seguir este tutorial e criar este exemplo pode gerar cobranças em sua conta da AWS . Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Pré-requisitos](#sample-php-prereqs)
+ [Etapa 1: Instalar as ferramentas necessárias](#sample-php-install)
+ [Etapa 2: Adicionar código](#sample-php-code)
+ [Etapa 3: Executar o código](#sample-php-run)
+ [Etapa 4: instalar e configurar o AWS SDK para PHP](#sample-php-sdk)
+ [Etapa 5: adicionar código AWS SDK](#sample-php-sdk-code)
+ [Etapa 6: executar o código do AWS SDK](#sample-php-sdk-run)
+ [Etapa 7: limpar](#sample-php-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar as ferramentas necessárias
Nesta etapa, instale a PHP, necessária para executar esse exemplo.
**nota**
O procedimento a seguir instala somente a PHP. Para instalar ferramentas relacionadas como um servidor web Apache e um banco de dados MySQL, consulte [Tutorial: Installing a LAMP Web Server on Amazon Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-LAMP.html) no *Manual do usuário do Amazon EC2*.
1. Em uma sessão de terminal no AWS Cloud9 IDE, confirme se o PHP já está instalado executando o **`php --version`**comando. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.) Se sim, a saída contém o número da versão PHP. Se o PHP estiver instalado, avance para [Etapa 2: Adicionar código](#sample-php-code).
1. Execute o comando ** `yum update` ** para Amazon Linux ou o comando ** `apt update` ** para Ubuntu Server a fim de ajudar a garantir que as atualizações de segurança e correções de bug mais recentes sejam instaladas.
Amazon Linux 2 e Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Instale a PHP executando o comando ** `install` **.
Para Amazon Linux 2:
```
sudo amazon-linux-extras install -y php7.2
```
Para Amazon Linux:
```
sudo yum -y install php72
```
**nota**
Você pode visualizar sua versão do Amazon Linux usando o comando a seguir.
```
cat /etc/system-release
```
Para Ubuntu Server:
```
sudo apt install -y php php-xml
```
Para obter mais informações, consulte [Instalação e configuração](http://php.net/manual/en/install.php) no site da PHP.
## Etapa 2: Adicionar código
No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o nome`hello.php`. (Para criar um arquivo, na barra de menus, selecione **File** (Arquivo), **New File (Novo arquivo)**. Para salvar o arquivo, selecione **File** (Arquivo), **Save (Salvar)**, digite `hello.php` como o **Filename (Nome do arquivo)** e escolha **Save** (Salvar).)
```
```
**nota**
O código anterior não depende de arquivos externos. No entanto, se você incluir ou precisar de outros arquivos PHP em seu arquivo e quiser usar esses arquivos AWS Cloud9 para completar o código enquanto digita, **ative a configuração Project, PHP Support, Enable PHP code complete** em **Preferences** e adicione os caminhos desses arquivos à configuração **Project, PHP Support, PHP Completion Include Paths**. (Para exibir e alterar as preferências, selecione **AWS Cloud9, Preferences** (Preferências) na barra de menus).
## Etapa 3: Executar o código
1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **PHP (cli)**.
1. Em **Comando**, digite `hello.php 5 9`. No código, `5` representa `$argv[1]` e `9` representa `$argv[2]`. (`$argv[0]` representa o nome do arquivo (`hello.php`).)
1. Selecione o botão **Executar** e compare a sua saída.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Saída da execução do código PHP no AWS Cloud9 IDE\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/ide-php-simple.png)
## Etapa 4: instalar e configurar o AWS SDK para PHP
Você pode aprimorar essa amostra para usar o AWS SDK para PHP para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar.
Nesta etapa, você instala e configura o AWS SDK para PHP, que fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do seu código PHP. Antes de instalar o AWS SDK para PHP, você deve instalar o [Composer.](https://getcomposer.org/) Depois de instalar o AWS SDK para PHP, você deve configurar o gerenciamento de credenciais em seu ambiente. Eles AWS SDK para PHP precisam dessas credenciais para interagir com os AWS serviços.
### Para instalar o Composer
Execute o comando ** `curl` ** com as opções silent (`-s`) e mostrar erro (`-S`), conectando o instalador do Composer em um arquivo PHP (PHAR), nomeado `composer.phar` por convenção.
```
curl -sS https://getcomposer.org/installer | php
```
### Para instalar o AWS SDK para PHP
Para Ubuntu Server, instale pacotes adicionais dos quais o Composer precisa para instalar o AWS SDK para PHP.
```
sudo apt install -y php-xml php-curl
```
Para o Amazon Linux ou o Ubuntu Server, use o comando **php** para executar o instalador do Composer para instalar o AWS SDK para PHP.
```
php composer.phar require aws/aws-sdk-php
```
Esse comando cria várias pastas e arquivos no ambiente. O arquivo primário que será usado é `autoload.php`, que se encontra na pasta `vendor` no ambiente.
**nota**
Após a instalação, o Composer pode sugerir que você instale dependências adicionais. Você pode fazer isso com um comando, como o seguinte, especificando a lista de dependências a serem instaladas. Por exemplo, o seguinte comando instrui o Composer a instalar a seguinte lista de dependências.
```
php composer.phar require psr/log ext-curl doctrine/cache aws/aws-php-sns-message-validator
```
Para obter mais informações, consulte [Instalação](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/installation.html) no *Guia do Desenvolvedor do AWS SDK para PHP *.
### Como configurar o gerenciamento de credenciais no ambiente
Cada vez que você usa o AWS SDK para PHP para chamar um AWS serviço, você deve fornecer um conjunto de credenciais com a chamada. Essas credenciais determinam se ele AWS SDK para PHP tem as permissões apropriadas para fazer essa chamada. Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.
Nesta etapa, você armazenará as credenciais no ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
Para obter mais informações, consulte a seção "Criação de um cliente" de [Uso básico](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/basic-usage.html) no *Guia do desenvolvedor do AWS SDK para PHP *.
## Etapa 5: adicionar código AWS SDK
Nesta etapa, adicione mais código, dessa vez para interagir com o Amazon S3 para criar um bucket, listar os buckets disponíveis e, excluir o bucket que você acabou de criar. Esse código será executado mais tarde.
No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o 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);
?>
```
## Etapa 6: executar o código do AWS SDK
1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **PHP (cli)**.
1. Em **Command (Comando)**, digite `s3.php America/Los_Angeles my-test-bucket us-east-2`, onde:
+ `America/Los_Angeles` é o ID de fuso horário padrão. Para obter mais informações IDs, consulte [Lista de fusos horários suportados](http://php.net/manual/en/timezones.php) no site do PHP.
+ `my-test-bucket` é o nome do bucket que você deseja criar e, em seguida, excluir.
**nota**
Os nomes dos buckets do Amazon S3 devem ser exclusivos em toda a sua conta, AWS não apenas em sua conta. AWS
+ `us-east-2`é o ID da AWS região na qual você deseja criar o bucket. Para obter mais informações IDs, consulte [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) no. *Referência geral da Amazon Web Services*
1. Selecione o botão **Executar** e compare a sua saída.
```
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:
```
## Etapa 7: limpar
Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
### Solução de problemas com o PHP runner para AWS Cloud9
Caso encontre problemas com o executor da CLI do PHP, você deve garantir que o executor tenha sido configurado para PHP e que o modo de depuração esteja ativado.
# AWS SDK para Ruby em AWS Cloud9
Para obter informações sobre como usar AWS Cloud9 com o AWS SDK for Ruby[, AWS Cloud9 consulte Usando AWS com o SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html) no Guia do desenvolvedor *AWS do SDK* for Ruby.
**nota**
Seguir este tutorial pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Amazon EC2 Pricing](https://aws.amazon.com/ec2/pricing/) e [Amazon S3](https://aws.amazon.com/s3/pricing/) Pricing.
# Tutorial Go para AWS Cloud9
Este tutorial permite que você execute alguns códigos em Go em um ambiente de AWS Cloud9 desenvolvimento.
Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Pré-requisitos](#sample-go-prereqs)
+ [Etapa 1: Instalar as ferramentas necessárias](#sample-go-install)
+ [Etapa 2: Adicionar código](#sample-go-code)
+ [Etapa 3: Executar o código](#sample-go-run)
+ [Etapa 4: instalar e configurar o AWS SDK para Go](#sample-go-sdk)
+ [Etapa 5: adicionar código AWS SDK](#sample-go-sdk-code)
+ [Etapa 6: executar o código do AWS SDK](#sample-go-sdk-run)
+ [Etapa 7: limpar](#sample-go-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar as ferramentas necessárias
Nesta etapa, instale e configure a Go, necessária para executar esse exemplo.
1. Em uma sessão de terminal no AWS Cloud9 IDE, confirme se o Go já está instalado executando o **`go version`**comando. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.) Se for bem-sucedido, a saída deve conter o número da versão Go. Caso contrário, será exibida uma mensagem de erro. Se o Go estiver instalado, avance para [Etapa 2: Adicionar código](#sample-go-code).
1. Execute o comando ** `yum update` ** para Amazon Linux ou o comando ** `apt update` ** para Ubuntu Server a fim de ajudar a garantir que as atualizações de segurança e correções de bug mais recentes sejam instaladas.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Para instalar a Go, execute esses comandos, um por vez.
```
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.
```
Os comandos anteriores assumem a versão estável mais recente da Go no momento em que este tópico foi escrito. Para obter mais informações, consulte [Downloads](https://golang.org/dl/) no site The Go Programming Language.
1. Adicione o caminho para o binário Go à variável de ambiente `PATH`, da seguinte forma.
1. Abra o arquivo de perfil de shell (por exemplo, `~/.bashrc`) para edição.
1. No final dessa linha de código, digite o seguinte, para que o código tenha a seguinte aparência.
```
PATH=$PATH:/usr/local/go/bin
```
1. Salve o arquivo.
1. Extraia o arquivo `~/.bashrc` para que o terminal possa encontrar o binário Go referenciado anteriormente.
```
. ~/.bashrc
```
1. Confirme se a Go foi instalada e configurada com sucesso executando o comando ** `go version` **. Se sim, a saída contém o número da versão Go.
## Etapa 2: Adicionar código
No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o nome`hello.go`. (Para criar um arquivo, na barra de menus, selecione **File** (Arquivo), **New File** (Novo arquivo). Para salvar o arquivo, selecione **File** (Arquivo), **Save** (Salvar).)
```
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))
}
```
## Etapa 3: Executar o código
1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Ir**.
**nota**
Se **Go** não estiver disponível, crie um executor personalizado para Go.
Na guia **[New] - Idle ([Novo] – Inativo)**, selecione **Runner: Auto (Executor: automático)** e, em seguida, selecione **New Runner (Novo executor)**.
Na guia **My Runner.run (Meu Runner.run)**, substitua o conteúdo da guia por esse código.
```
{
"cmd" : ["go", "run", "$file", "$args"],
"info" : "Running $project_path$file_name...",
"selector" : "source.go"
}
```
Selecione **File (Arquivo)**, **Save As (Salvar como)** na barra de menus e salve o arquivo como `Go.run` na pasta `/.c9/runners`.
Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Ir**.
Selecione a guia **hello.go** para ativá-la.
1. Em **Comando**, digite `hello.go 5 9`. No código, `5` representa `os.Args[1]` e `9` representa `os.Args[2]`.
![\[Saída da execução do código Go no AWS Cloud9 IDE\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/ide-go-simple.png)
1. Selecione o botão **Executar** e compare a sua saída.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Etapa 4: instalar e configurar o AWS SDK para Go
Você pode aprimorar essa amostra para usar o AWS SDK para Go para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar.
Nesta etapa, você instala e configura o AWS SDK para Go, que fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do seu código Go. Antes de instalar o AWS SDK para Go, defina a variável de ambiente `GOPATH`. Após instalar o AWS SDK para Go e definir a variável de ambiente `GOPATH`, configure o gerenciamento de credenciais no ambiente. Eles AWS SDK para Go precisam dessas credenciais para interagir com os AWS serviços.
### Para definir a variável de ambiente GOPATH
1. Abra o arquivo `~/.bashrc` para edição.
1. Após a última linha no arquivo, digite esse código.
```
GOPATH=~/environment/go
export GOPATH
```
1. Salve o arquivo.
1. Extraia o arquivo `~/.bashrc` para que o terminal possa encontrar a variável de ambiente `GOPATH` referenciada anteriormente.
```
. ~/.bashrc
```
1. Confirme se a variável de ambiente `GOPATH` foi definida com sucesso executando o comando ** `echo $GOPATH`**. Se tiver êxito, a saída deverá ser `/home/ec2-user/environment/go` ou `/home/ubuntu/environment/go`.
### Para instalar o AWS SDK para Go
Execute o **`go get`**comando, especificando a localização da AWS SDK para Go fonte.
```
go get -u github.com/aws/aws-sdk-go/...
```
O Go instala a AWS SDK para Go fonte no local especificado pela variável de `GOPATH` ambiente, que é a `go` pasta em seu ambiente.
### Como configurar o gerenciamento de credenciais no ambiente
Cada vez que você usa o AWS SDK para Go para ligar para um AWS serviço, você deve fornecer um conjunto de credenciais com a chamada. Essas credenciais determinam se ele AWS SDK para Go tem as permissões apropriadas para fazer essa chamada. Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.
Nesta etapa, você armazenará as credenciais no ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
Para obter mais informações, consulte [Specifying Credentials](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials)(Especificar credenciais) no *Manual do desenvolvedor do AWS SDK para Go *.
## Etapa 5: adicionar código AWS SDK
Nesta etapa, adicione mais código, dessa vez para interagir com o Amazon S3 para criar um bucket, listar os buckets disponíveis e, excluir o bucket que você acabou de criar. Esse código será executado mais tarde.
No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o 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)
}
```
## Etapa 6: executar o código do AWS SDK
1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Ir**.
1. Em **Command**`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `, digite, onde ` YOUR_BUCKET_NAME ` está o nome do bucket que você deseja criar e depois excluir, e ` THE_AWS_REGION ` é o ID da AWS região na qual você deseja criar o bucket. Por exemplo, para a região Leste dos EUA (Ohio), use `us-east-2`. Para obter mais informações IDs, consulte [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) no. *Referência geral da Amazon Web Services*
**nota**
Os nomes dos buckets do Amazon S3 devem ser exclusivos em toda a sua conta, AWS não apenas em sua conta. AWS
1. Selecione o botão **Executar** e compare a sua saída.
```
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:
```
## Etapa 7: limpar
Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# TypeScript tutorial para AWS Cloud9
Este tutorial mostra como trabalhar TypeScript em um ambiente de AWS Cloud9 desenvolvimento.
Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Pré-requisitos](#sample-typescript-prereqs)
+ [Etapa 1: Instalar as ferramentas necessárias](#sample-typescript-install)
+ [Etapa 2: Adicionar código](#sample-typescript-code)
+ [Etapa 3: Executar o código](#sample-typescript-run)
+ [Etapa 4: instalar e configurar o AWS SDK para JavaScript no Node.js](#sample-typescript-sdk)
+ [Etapa 5: adicionar código AWS SDK](#sample-typescript-sdk-code)
+ [Etapa 6: executar o código do AWS SDK](#sample-typescript-sdk-run)
+ [Etapa 7: limpar](#sample-typescript-clean-up)
## Pré-requisitos
Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).
## Etapa 1: Instalar as ferramentas necessárias
Nesta etapa, você instala TypeScript usando o Node Package Manager (**`npm`**). Para instalar ** `npm` **, você usa o Gerenciador de versão do Node (** `nvm` **). Se você não tiver ** `nvm` **, instale-o nesta etapa primeiro.
1. Em uma sessão de terminal no AWS Cloud9 IDE, confirme se já TypeScript está instalado executando o TypeScript compilador de linha de comando com a **`--version`**opção. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.) Se for bem-sucedida, a saída conterá o número da TypeScript versão. Se TypeScript estiver instalado, vá para[Etapa 2: Adicionar código](#sample-typescript-code).
```
tsc --version
```
1. Confirme se o ** `npm` ** já está instalado executando o ** `npm` ** com a opção ** `--version` **. Se sim, a saída contém o número da versão ** `npm` **. Se **`npm`**estiver instalado, vá para a etapa 10 deste procedimento **`npm`**para usar na instalação TypeScript.
```
npm --version
```
1. Execute o comando ** `yum update` ** para Amazon Linux ou o comando ** `apt update` ** para Ubuntu Server a fim de ajudar a garantir que as atualizações de segurança e correções de bug mais recentes sejam instaladas.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Para instalar **`npm`**, comece executando o comando a seguir para baixar o Node Version Manager (**`nvm`**). (**`nvm`**é um script de shell Bash simples que é útil para instalar e gerenciar versões do Node.js. Para obter mais informações, consulte [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md) no GitHub site.)
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Para começar a usar o ** `nvm` **, feche a sessão de terminal e inicie-a novamente ou extraia o arquivo `~/.bashrc` que contém os comandos para carregar o ** `nvm` **.
```
. ~/.bashrc
```
1. Confirme se o ** `nvm` ** está instalado executando o ** `nvm` ** com a opção ** `--version` **.
```
nvm --version
```
1. Instale a versão 16 mais recente do Node.js executando ** `nvm` **. (** `npm` ** está incluído em Node.js.)
```
nvm install v16
```
1. Confirme se o Node.js está instalado executando a versão de linha de comando do Node.js com a opção ** `--version` **.
```
node --version
```
1. Confirme se o ** `npm` ** está instalado executando o ** `npm` ** com a opção ** `--version` **.
```
npm --version
```
1. Instale TypeScript executando **`npm`**com a **`-g`**opção. Isso é instalado TypeScript como um pacote global no ambiente.
```
npm install -g typescript
```
1. Confirme se TypeScript está instalado executando o TypeScript compilador de linha de comando com a **`--version`**opção.
```
tsc --version
```
## Etapa 2: Adicionar código
1. No AWS Cloud9 IDE, crie um arquivo chamado`hello.ts`. (Para criar um arquivo, na barra de menus, selecione **File** (Arquivo), **New File** (Novo arquivo). Para salvar o arquivo, selecione **File** (Arquivo), **Save** (Salvar).)
1. Em um terminal no IDE, no mesmo diretório que o arquivo `hello.ts`, execute ** `npm` ** para instalar a biblioteca `@types/node`.
```
npm install @types/node
```
Isso adiciona uma pasta `node_modules/@types/node` no mesmo diretório que o arquivo `hello.ts`. Essa nova pasta contém as definições do tipo Node.js que serão TypeScript necessárias posteriormente neste procedimento para as `process.argv` propriedades `console.log` e que você adicionará ao `hello.ts` arquivo.
1. Adicione o seguinte código ao arquivo `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 + '.');
```
## Etapa 3: Executar o código
1. No terminal, no mesmo diretório do `hello.ts` arquivo, execute o TypeScript compilador. Especifique o arquivo `hello.ts` e bibliotecas adicionais a serem incluídas.
```
tsc hello.ts --lib es6
```
TypeScript usa o `hello.ts` arquivo e um conjunto de ECMAScript 6 (ES6) arquivos de biblioteca para transpilar o TypeScript código no `hello.ts` arquivo em JavaScript código equivalente em um arquivo chamado. `hello.js`
1. Na janela **Ambiente**, abra o arquivo `hello.js`.
1. Na barra de menus, selecione **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Node.js**.
1. Em **Comando**, digite `hello.js 5 9`. No código, `5` representa `process.argv[2]`, e `9` representa `process.argv[3]`. (`process.argv[0]` representa o nome do tempo de execução (`node`) e `process.argv[1]` representa o nome do arquivo (`hello.js`).)
1. Selecione **Executar** e compare sua saída. Quando terminar, selecione **Parar**.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Saída Node.js após executar o código no AWS Cloud9 IDE\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**nota**
Em vez de criar uma nova configuração de execução no IDE, você também pode executar esse código executando o comando ** `node hello.js 5 9` ** no terminal.
## Etapa 4: instalar e configurar o AWS SDK para JavaScript no Node.js
Você pode aprimorar essa amostra para usar o AWS SDK JavaScript em Node.js para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar.
Nesta etapa, você instala e configura o AWS SDK para o JavaScript Node.js. O SDK fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do JavaScript seu código. Depois de instalar o AWS SDK para JavaScript no Node.js, você deve configurar o gerenciamento de credenciais em seu ambiente. O SDK precisa dessas credenciais para interagir com AWS os serviços.
### Para instalar o AWS SDK JavaScript em Node.js
Em uma sessão de terminal no AWS Cloud9 IDE, no mesmo diretório do `hello.js` arquivo[Etapa 3: Executar o código](#sample-typescript-run), execute **`npm`**para instalar o AWS SDK JavaScript em Node.js.
```
npm install aws-sdk
```
Esse comando adiciona várias pastas à pasta `node_modules` em [Etapa 3: Executar o código](#sample-typescript-run). Essas pastas contêm o código-fonte e as dependências do AWS SDK JavaScript em Node.js. Para obter mais informações, consulte [Instalação do SDK JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) no *Guia do AWS SDK para JavaScript desenvolvedor*.
### Como configurar o gerenciamento de credenciais no ambiente
Sempre que você usa o AWS SDK do Node.js para JavaScript chamar um AWS serviço, você deve fornecer um conjunto de credenciais com a chamada. Essas credenciais determinam se o AWS SDK do Node.js tem as permissões apropriadas para fazer essa chamada. JavaScript Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.
Nesta etapa, você armazenará as credenciais no ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.
Para obter mais informações, consulte [Setting Credentials in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html) (Definir credenciais no Node.js) no *Manual do desenvolvedor do AWS SDK para JavaScript *.
## Etapa 5: adicionar código AWS SDK
Nesta etapa, adicione mais código, dessa vez para interagir com o Amazon S3 para criar um bucket, listar os buckets disponíveis e, excluir o bucket que você acabou de criar. Esse código será executado mais tarde.
1. No AWS Cloud9 IDE, no mesmo diretório do `hello.js` arquivo nas etapas anteriores, crie um arquivo chamado`s3.ts`.
1. Em um terminal no AWS Cloud9 IDE, no mesmo diretório do `s3.ts` arquivo, habilite o código para chamar as operações do Amazon S3 de forma assíncrona executando **`npm`**duas vezes para instalar a biblioteca assíncrona e novamente para. TypeScript JavaScript
```
npm install @types/async # For TypeScript.
npm install async # For JavaScript.
```
1. Adicione o seguinte código ao arquivo `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
]);
```
## Etapa 6: executar o código do AWS SDK
1. No terminal, no mesmo diretório do `s3.ts` arquivo, execute o TypeScript compilador. Especifique o arquivo `s3.ts` e bibliotecas adicionais a serem incluídas.
```
tsc s3.ts --lib es6
```
TypeScript usa o `s3.ts` arquivo, o AWS SDK do Node.js, a biblioteca JavaScript assíncrona e um conjunto de arquivos de biblioteca ECMAScript 6 (ES6) para transpilar o TypeScript código no arquivo em JavaScript código equivalente em um `s3.ts` arquivo chamado. `s3.js`
1. Na janela **Ambiente**, abra o arquivo `s3.js`.
1. Na barra de menus, selecione **Executar**, **Configurações de execução**, **Nova configuração de execução**.
1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Node.js**.
1. Em **Command**`s3.js YOUR_BUCKET_NAME THE_AWS_REGION `, digite, onde ` YOUR_BUCKET_NAME ` está o nome do bucket que você deseja criar e depois excluir, e ` THE_AWS_REGION ` é o ID da AWS região na qual criar o bucket. Por exemplo, para a região Leste dos EUA (Ohio), use `us-east-2`. Para obter mais informações IDs, consulte [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) no. *Referência geral da Amazon Web Services*
**nota**
Os nomes dos buckets do Amazon S3 devem ser exclusivos em toda a sua conta, AWS não apenas em sua conta. AWS
1. Selecione **Executar** e compare sua saída. Quando terminar, selecione **Parar**.
```
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:
```
## Etapa 7: limpar
Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
# Tutorial do Docker para AWS Cloud9
Este tutorial mostra como conectar um ambiente de desenvolvimento AWS Cloud9 SSH a um contêiner Docker em execução dentro de uma instância do Amazon Linux no Amazon EC2. Isso permite que você use o AWS Cloud9 IDE para trabalhar com código e arquivos dentro de um contêiner Docker e executar comandos nesse contêiner. Para obter informações sobre o Docker, consulte [O que é o Docker](https://www.docker.com/what-docker) no site do Docker.
Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como o Amazon EC2. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Pré-requisitos](#sample-docker-prereqs)
+ [Etapa 1: Instalar e executar o Docker](#sample-docker-install)
+ [Etapa 2: Compilar a imagem](#sample-docker-build)
+ [Etapa 3: Executar o contêiner](#sample-docker-run)
+ [Etapa 4: Criar o ambiente](#sample-docker-env)
+ [Etapa 5: Executar o código](#sample-docker-code)
+ [Etapa 6: limpar](#sample-docker-clean-up)
## Pré-requisitos
+ **Você deve ter uma instância do Amazon EC2 executando o Amazon Linux ou Ubuntu Server.** Este exemplo pressupõe que você já tenha uma instância do Amazon EC2 executando o Amazon Linux ou o Ubuntu Server em AWS sua conta. Para iniciar uma instância do Amazon EC2, consulte [Launch a Linux Virtual Machine](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/) (Iniciar uma máquina virtual do Linux). Na página **Choose an Amazon Machine Image (AMI)** (Selecionar uma Imagem de máquina da Amazon - AMI) do assistente, selecione uma AMI cujo nome exibido começa com **Amazon Linux AMI** ou **Ubuntu Server**.
+ **Se a instância do Amazon EC2 for executada em uma Amazon VPC, haverá requisitos adicionais.** Consulte [Configurações de VPC para ambientes de desenvolvimento AWS Cloud9](vpc-settings.md).
+ **A instância do Amazon EC2 deve ter pelo menos 8 a 16 GB de espaço livre em disco disponível.** Essa amostra usa imagens do Docker com mais de 3 GB de tamanho e pode usar incrementos adicionais de 3 GB ou mais de espaço em disco para compilar imagens. Se você tentar executar essa amostra em um disco com 8 GB ou menos de espaço livre, descobrimos que a imagem do Docker poderá não ser compilada ou o contêiner do Docker poderá não ser executado. Para verificar o espaço livre em disco da instância, execute um comando, como ** `df -h` ** (para "informações do sistema de arquivos do disco em formato legível"), na instância. Para aumentar o tamanho do disco em uma instância existente, consulte [Modificar um volume](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html) no *Manual do usuário do Amazon EC2*.
## Etapa 1: Instalar e executar o Docker
Nesta etapa, verifique se o Docker está instalado na instância do Amazon EC2 e instale-o, caso ainda não esteja. Depois de instalar o Docker, execute-o na instância.
1. Conecte-se à instância do Amazon EC2; em execução usando um cliente SSH, como o utilitário ** `ssh` ** ou o PuTTY. Para fazer isso, consulte a "Etapa 3: Conectar-se à instância" em [Iniciar uma máquina virtual do Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/).
1. Verifique se o Docker está instalado na instância. Para fazer isso, execute o comando ** `docker` ** na instância com a opção ** `--version` **.
```
docker --version
```
Se o Docker estiver instalado, a versão do Docker e o número de compilação são exibidos. Nesse caso, avance para a etapa 5 desse procedimento.
1. Instalar o Docker. Para fazer isso, execute o comando ** `yum` ** ou ** `apt` ** com a ação ** `install` **, especificando o pacote ** `docker` ** ou ** `docker.io` ** a ser instalado.
Para Amazon Linux:
```
sudo yum install -y docker
```
Para Ubuntu Server:
```
sudo apt install -y docker.io
```
1. Confirme se o Docker está instalado. Para fazer isso, execute o comando ** `docker --version` ** novamente. A versão do Docker e o número de compilação são exibidos.
1. Execute o Docker. Para fazer isso, execute o comando ** `service` ** com o serviço ** `docker` ** e a ação ** `start` **.
```
sudo service docker start
```
1. Confirme se o Docker está em execução. Para fazer isso, execute o comando ** `docker` ** com a ação ** `info` **.
```
sudo docker info
```
Se o Docker estiver em execução, serão exibidas informações sobre ele.
## Etapa 2: Compilar a imagem
Nesta etapa, você usará eum Dockerfile para compilar uma imagem do Docker na instância. Essas amostra usa uma imagem que inclui Node.js e uma amostra de aplicativo de servidor de bate-papo.
1. Na instância, crie o Dockerfile. Para fazer isso, com o cliente SSH ainda conectado à instância, no diretório `/tmp` na instância, crie um arquivo chamado `Dockerfile`. Por exemplo, execute o comando ** `touch` ** da seguinte forma.
```
sudo touch /tmp/Dockerfile
```
1. Adicione o conteúdo a seguir ao arquivo `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
```
Para adicionar o conteúdo anterior ao arquivo `Dockerfile`, use o utilitário ** `vi` ** na instância da seguinte forma.
1. Use o AWS Cloud9 para abrir e editar o `/tmp/Dockerfile` arquivo.
```
sudo vi /tmp/Dockerfile
```
1. Cole o conteúdo anterior no arquivo `Dockerfile`. Se não tiver certeza sobre como fazer isso, consulte a documentação do seu cliente SSH.
1. Alterne para o modo de comandos. Para fazer isso, pressione a tecla `Esc`. (`-- INSERT --` desaparece na parte inferior da janela.)
1. Digite `:wq` (para gravar no arquivo `/tmp/Dockerfile`, salvar o arquivo e, em seguida, sair do ** `vi` **) e, em seguida, pressione `Enter`.
**nota**
Você pode acessar uma lista atualizada com frequência de imagens do AWS CodeBuild Docker em. Para obter mais informações, consulte [as imagens do Docker fornecidas CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html) no *Guia do AWS CodeBuild usuário*.
1. Na instância, crie um arquivo que contenha a chave pública AWS Cloud9 SSH para o contêiner do Docker usar. Para fazer isso, no mesmo diretório que o arquivo `Dockerfile`, crie um arquivo chamado `authorized_keys`, por exemplo, executando o comando ** `touch` **.
```
sudo touch /tmp/authorized_keys
```
1. Adicione a chave pública AWS Cloud9 SSH ao `authorized_keys` arquivo. Para obter a chave pública AWS Cloud9 SSH, faça o seguinte:
1. Abra o AWS Cloud9 console em [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).
1. Na barra de AWS navegação, no seletor de AWS região, escolha a AWS região em que você deseja criar o ambiente de AWS Cloud9 desenvolvimento posteriormente neste tópico.
1. Se uma página de boas-vindas for exibida, em **Novo AWS Cloud9 ambiente**, escolha **Criar ambiente**. Caso contrário, selecione **Criar ambiente**.
1. Na página **Name environment (Nomear ambiente)**, em **Name (Nome)**, digite um nome para o ambiente. (Aqui o nome não importa. Mais tarde você escolherá um nome diferente).
1. Escolha **Próxima etapa**.
1. Em **Environment type (Tipo de ambiente)**, selecione **Connect and run in remote server (SSH) (Conectar e executar no servidor remoto (SSH))**.
1. Expanda **View public SSH key (Exibir chave SSH pública)**.
1. Escolha **Copy key to clipboard (Copiar chave para a área de transferência)**. (Ela se encontra entre **View public SSH key (Exibir chave SSH pública)** e **Advanced settings (Configurações avançadas)**.)
1. Escolha **Cancelar**.
1. Cole o conteúdo da área de transferência no arquivo `authorized_keys` e, em seguida, salve o arquivo. Por exemplo, use o utilitário ** `vi` **, conforme descrito anteriormente nessa etapa.
1. Construa a imagem executando o comando ** `docker` ** com a ação ** `build` **, adicionando a tag `cloud9-image:latest` à imagem e especificando o caminho que o arquivo `Dockerfile` deve usar.
```
sudo docker build -t cloud9-image:latest /tmp
```
Se for bem-sucedida, as últimas duas linhas da saída da compilação exibem `Successfully built` e `Successfully tagged`.
Para confirmar se o Docker compilou a imagem com sucesso, execute o comando ** `docker` ** com a ação `image ls`.
```
sudo docker image ls
```
Se for bem-sucedida, a saída mostra uma entrada onde o campo `REPOSITORY` está definido como `cloud9-image` e o campo `TAG` está definido como `latest`.
1. Anote o endereço IP público da instância do Amazon EC2. Você precisará disso para o [Etapa 4: Criar o ambiente](#sample-docker-env). Se não tiver certeza de qual é o endereço IP público da instância, execute o seguinte comando na instância para obtê-lo.
```
curl http://169.254.169.254/latest/meta-data/public-ipv4
```
## Etapa 3: Executar o contêiner
Nesta etapa, execute um contêiner do Docker na instância. Esse contêiner se baseia na imagem compilada na etapa anterior.
1. Para executar o contêiner do Docker, execute o comando ** `docker` ** na instância com a ação ** `run` ** e as opções a seguir.
```
sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
```
+ `-d` executa o contêiner no modo desanexado, saindo sempre que o processo raiz usado para executar o contêiner (nessa amostra, o cliente SSH) for encerrado.
+ `-it` executa o contêiner com um pseudo-TTY alocado e mantém STDIN aberto, mesmo se o contêiner não estiver anexado.
+ `--expose` disponibiliza a porta especificada (nessa amostra, porta `9090`) no contêiner.
+ `-p` disponibiliza a porta especificada internamente para a instância do Amazon EC2 pelo endereço IP e a porta especificados. Neste exemplo, a porta `9090` no contêiner pode ser acessada internamente através da porta `22` na instância do Amazon EC2.
+ `--name` é um nome legível para o contêiner (nessa amostra, `cloud9`).
+ `cloud9-image:latest` é o nome legível da imagem compilada usado para executar o contêiner.
Para confirmar se o Docker está executando o contêiner com sucesso, execute o comando ** `docker` ** com a ação `container ls`.
```
sudo docker container ls
```
Se for bem-sucedida, a saída mostra uma entrada onde o campo `IMAGE` está definido como `cloud9-image:latest` e o campo `NAMES` está definido como `cloud9`.
1. Faça login no contêiner em execução. Para fazer isso, execute o comando ** `docker` ** com a ação ** `exec` ** e as opções a seguir.
```
sudo docker exec -it cloud9 bash
```
+ `-it` executa o contêiner com um pseudo-TTY alocado e mantém STDIN aberto, mesmo se o contêiner não estiver anexado.
+ `cloud9` é o nome legível do contêiner em execução.
+ `bash` inicia o shell padrão no contêiner em execução.
Se for bem-sucedido, o prompt do terminal muda para exibir o nome do usuário conectado para o contêiner e o ID do contêiner.
**nota**
Caso queira fazer logout do contêiner em execução, execute o comando ** `exit` **. O prompt do terminal muda de volta para exibir o nome do usuário conectado para a instância e o DNS privado da instância. O contêiner ainda deve estar em execução.
1. Para o diretório no contêiner em execução a partir do qual você AWS Cloud9 deseja iniciar após o login, defina suas permissões de acesso como **`rwxr-xr-x`**. Isso significa read-write-execute permissões para o proprietário, permissões de leitura e execução para o grupo e permissões de leitura e execução para outros. Por exemplo, se o caminho do diretório for `~`, defina essas permissões no diretório executando o comando ** `chmod` ** no contêiner em execução, da seguinte forma.
```
sudo chmod u=rwx,g=rx,o=rx ~
```
1. Anote o caminho para o diretório no contêiner em execução que contém o binário Node.js, pois isso será necessário para [Etapa 4: Criar o ambiente](#sample-docker-env). Se não tiver certeza sobre qual é o caminho, execute o comando a seguir no contêiner em execução para obtê-lo.
```
which node
```
## Etapa 4: Criar o ambiente
Nesta etapa, você usa AWS Cloud9 para criar um ambiente de desenvolvimento AWS Cloud9 SSH e conectá-lo ao contêiner Docker em execução. Depois de AWS Cloud9 criar o ambiente, ele exibe o AWS Cloud9 IDE para que você possa começar a trabalhar com os arquivos e o código no contêiner.
Você cria um ambiente de desenvolvimento AWS Cloud9 SSH com o AWS Cloud9 console. Não é possível criar um ambiente de SSH usando a CLI.
### Pré-requisitos
+ Primeiro você precisa concluir as etapas em [Conf AWS Cloud9 iguração](setting-up.md). Dessa forma, você pode fazer login no console do AWS Cloud9 e criar ambientes.
+ Identifique uma instância de computação em nuvem existente (por exemplo, uma instância do Amazon EC2 na Conta da AWS sua) ou seu próprio servidor que você AWS Cloud9 deseja conectar ao ambiente.
+ Certifique-se de que a instância existente ou seu próprio servidor atende a todos os [Requisitos de host SSH](ssh-settings.md#ssh-settings-requirements). Isso inclui ter versões específicas do Python, Node.js e de outros componentes já instaladas; definir permissões específicas no diretório em que você deseja que o AWS Cloud9 seja iniciado após fazer login; e configurar qualquer Amazon Virtual Private Cloud associada.
### Crie um ambiente SSH
1. Atenda aos pré-requisitos anteriores.
1. Conecte-se à instância existente ou ao seu próprio servidor usando um cliente SSH, se ainda não estiver conectado a ele. Isso garante que você possa adicionar o valor necessário da chave SSH pública à instância ou ao servidor. Isso é descrito posteriormente neste procedimento.
**nota**
Para se conectar a uma instância de Nuvem AWS computação existente, consulte um ou mais dos seguintes recursos:
Para o Amazon EC2, consulte [Conectar-se à instância do Linux usando SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) no *Manual do usuário do Amazon EC2*.
Para o Amazon Lightsail, consulte [Conectar-se à instância Lightsail do Linux/baseada em Unix](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server) na *Documentação do Amazon Lightsail*.
Para AWS Elastic Beanstalk isso, consulte [Listagem e conexão com instâncias de servidor](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.ec2connect.html) no *Guia do AWS Elastic Beanstalk desenvolvedor*.
Para AWS OpsWorks isso, consulte [Como usar SSH para fazer login em uma instância do Linux](https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-ssh.html) no *Guia do AWS OpsWorks usuário*.
Para outras Serviços da AWS informações, consulte a documentação desse serviço específico.
Para se conectar ao seu próprio servidor, use SSH. O SSH já está instalado nos sistemas operacionais macOS e Linux. Para se conectar ao seu servidor usando SSH no Windows, você deve instalar o [PuTTY](https://www.putty.org/).
1. Faça login no AWS Cloud9 console, em [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).
1. Depois de entrar no AWS Cloud9 console, na barra de navegação superior, escolha um Região da AWS para criar o ambiente. Para obter uma lista dos disponíveis Regiões da AWS, consulte [AWS Cloud9](https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region)no *Referência geral da AWS*.
![\[Seletor de região no console AWS Cloud9\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/consolas_region_new_UX.png)
1. Se esta for a primeira vez que você cria um ambiente de desenvolvimento, uma página de boas-vindas será exibida. No painel **Novo AWS Cloud9 ambiente**, escolha **Criar ambiente**.
Se você já criou ambientes de desenvolvimento anteriormente, também poderá expandir o painel à esquerda da tela. Selecione **Your environments** (Seus ambientes) e, depois, selecione **Create environment** (Criar ambiente).
Na página de **boas-vindas**:
![\[Selecione o botão Create environment (Criar ambiente) se a página de boas-vindas não for exibida\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)
Ou na página **Seus ambientes**:
![\[Selecione o botão Create environment (Criar ambiente) se a página de boas-vindas não for exibida\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/console_create_env_new_UX.png)
1. Na página **Create environment** (Criar ambiente), digite um nome para o ambiente.
1. Em **Descrição**, insira algo sobre seu ambiente. Para este tutorial, use `This environment is for the AWS Cloud9 tutorial.`
1. Em **Environment type** (Tipo de ambiente), selecione **Existing Compute** (Computação existente) entre as seguintes opções:
+ **Nova instância do EC2** — Lança uma instância do Amazon EC2 AWS Cloud9 que pode se conectar diretamente via SSH.
+ **Computação existente — Lança** uma instância do Amazon EC2 que não exige nenhuma porta de entrada aberta. AWS Cloud9 se conecta à instância por meio de [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html).
+ Se você selecionar a opção **Existing compute** (Computação existente), um perfil de serviço e um perfil de instância do IAM serão criados automaticamente para permitir que o Systems Manager interaja com a instância do EC2 em seu nome. Você pode visualizar os nomes na seção **Perfil de serviço e perfil de instância para acesso ao Systems Manager** mais abaixo na interface. Para obter mais informações, consulte [Acessando instâncias EC2 sem entrada com AWS Systems Manager](ec2-ssm.md).
**Atenção**
Criar uma instância do EC2 para o seu ambiente pode resultar em possíveis cobranças Conta da AWS para o Amazon EC2. Não há custo adicional para usar o Systems Manager para gerenciar conexões com sua instância do EC2.
**Atenção**
AWS Cloud9 usa a chave pública SSH para se conectar com segurança ao seu servidor. Para estabelecer a conexão segura, adicione nossa chave pública ao seu arquivo `~/.ssh/authorized_keys` e forneça suas credenciais de login nas etapas a seguir. Selecione **Copy key to clipboard** (Copiar chave na área de transferência) para copiar a chave SSH ou **View public SSH key to display it** (Exibir chave SSH pública para exibi-la).
1. No painel **Existing compute** (Computação existente), para **User** (Usuário), insira o nome de login que você usou para se conectar à instância ou ao servidor anteriormente neste procedimento. Por exemplo, para uma instância de computação da Nuvem AWS , pode ser `ec2-user`, `ubuntu` ou `root`.
**nota**
Recomendamos que o nome de login seja associado a permissões administrativas ou a um usuário administrador na instância ou no servidor. Mais especificamente, recomendamos que esse nome de login tenha a instalação do Node.js na instância ou no servidor. Para verificar isso, no terminal da instância ou do servidor, execute o comando **`ls -l $(which node)`** (ou **`ls -l $(nvm which node)`**, se estiver usando `nvm`). Esse comando exibe o nome do proprietário da instalação do Node.js. Ele também exibe as permissões, o nome do grupo e o local da instalação.
1. Em **Host**, digite o endereço IP público (preferencial) ou o nome de host da instância ou do servidor.
1. Em **Porta**, insira a porta que você AWS Cloud9 deseja usar para tentar se conectar à instância ou ao servidor. Como alternativa, mantenha a porta padrão.
1. Selecione **Additional details - optional** (Detalhes adicionais: opcional) para exibir o caminho do ambiente, o caminho para o binário node.js e as informações do host de salto SSH.
1. Em **Environment path**, insira o caminho para o diretório na instância ou no servidor a partir do qual você AWS Cloud9 deseja começar. Você identificou isso anteriormente nos pré-requisitos para este procedimento. Se deixar em branco, o AWS Cloud9 usará o diretório com o qual a instância ou o servidor normalmente inicia após o login. Geralmente é um diretório de início ou padrão.
1. Em **Path to Node.js binary path** (Caminho para o caminho binário do Node.js), insira as informações do caminho para especificar o caminho para o binário Node.js na instância ou no servidor. Para obter o caminho, execute o comando **`which node`** (ou ** `nvm which node` **, se estiver usando `nvm`) na instância ou no servidor. Por exemplo, o caminho pode ser `/usr/bin/node`. Se você deixar isso em branco, o AWS Cloud9 tentará adivinhar onde o binário do Node.js está ao tentar conectar.
1. Em **SSH jump host** (Host de salto SSH), insira informações sobre o host de salto que a instância ou o servidor usa. Use o formato `USER_NAME@HOSTNAME:PORT_NUMBER` (por exemplo, `ec2-user@:ip-192-0-2-0:22`).
O host de salto deve atender aos seguintes requisitos:
+ Ele deve ser acessível pela internet pública usando SSH.
+ Ele deve permitir acesso de entrada por qualquer endereço IP através da porta especificada.
+ O valor da chave SSH pública que foi copiada para o arquivo `~/.ssh/authorized_keys` na instância existente ou servidor também deve ser copiado para o arquivo `~/.ssh/authorized_keys` no jump host.
+ O Netcat deve ser instalado.
1. Adicione até 50 tags fornecendo uma **Chave** e um **Valor** para cada tag. Faça isso selecionando **Add new tag** (Adicionar nova tag). As tags são anexadas ao AWS Cloud9 ambiente como tags de recursos e propagadas para os seguintes recursos subjacentes: a CloudFormation pilha, a instância do Amazon EC2 e os grupos de segurança do Amazon EC2. Para saber mais sobre tags, consulte [Controlar o acesso usando tags de AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) no *[Guia do usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/)* e [as informações avançadas](tags.md) sobre tags neste guia.
**Atenção**
Se você atualizar essas tags depois de criá-las, as alterações não serão propagadas para os recursos subjacentes. Para obter mais informações, consulte [Propagar atualizações de tags nos recursos subjacentes](tags.md#tags-propagate) nas informações avançadas sobre [tags](tags.md).
1. Selecione **Create** (Criar) para criar seu ambiente e, depois, você será redirecionado para a página inicial. Quando a conta é criada com sucesso, uma barra flash verde aparece na parte superior do AWS Cloud9 console. Você pode selecionar o novo ambiente e escolher **Open in Cloud9** (Abrir no Cloud9) para iniciar o IDE.
![\[AWS Cloud9 Seletor IDE no console AWS Cloud9\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/cloud9-ide-open.png)
Se a conta não for criada, uma barra flash verde aparecerá na parte superior do console do AWS Cloud9 . Sua conta pode falhar na criação devido a um problema com seu navegador, suas permissões de AWS acesso, a instância ou a rede associada. Você pode encontrar informações sobre possíveis correções para problemas que podem causar falhas na conta na seção [Solução de problemas no AWS Cloud9 .](troubleshooting.md#troubleshooting-env-loading)
**nota**
Se seu ambiente estiver usando um proxy para acessar a Internet, você deverá fornecer detalhes do proxy para que ele AWS Cloud9 possa instalar dependências. Para obter mais informações, consulte [Falha ao instalar as dependências](troubleshooting.md#proxy-failed-dependencies).
## Etapa 5: Executar o código
Nesta etapa, você usa o AWS Cloud9 IDE para executar um aplicativo de amostra dentro do contêiner Docker em execução.
1. Com o AWS Cloud9 IDE exibido para o contêiner em execução, inicie o servidor de bate-papo de amostra. Para fazer isso, na janela **Environment (Ambiente)**, clique com o botão direito do mouse no arquivo de amostra `workspace/server.js` e, em seguida, selecione **Run (Executar)**.
1. Visualize o aplicativo de exemplo. Para fazer isso, na janela **Environment (Ambiente)**, abra o arquivo `workspace/client/index.html`. Em seguida, na barra de menus, selecione **Tools, Preview, Preview Running Application (Ferramentas, Visualizar, Visualizar o aplicativo em execução)**.
1. Na guia de visualização do aplicativo, em **Your Name (Seu nome)**, digite o seu nome. Em **Mensagem**, digite uma mensagem. Em seguida, selecione **Send (Enviar)**. O servidor de bate-papo adiciona o seu nome e a mensagem à lista.
## Etapa 6: limpar
Nesta etapa, você exclui o ambiente AWS Cloud9 e remove os arquivos de suporte do Docker da instância do Amazon EC2. Além disso, para evitar cobranças contínuas em sua AWS conta depois de terminar de usar essa amostra, você deve encerrar a instância do Amazon EC2 que está executando o Docker.
### Etapa 6.1: Excluir o ambiente
Para excluir o ambiente, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).
### Etapa 6.2: Remover arquivos de AWS Cloud9 suporte do contêiner
Depois de excluir o ambiente, alguns arquivos de AWS Cloud9 suporte ainda permanecem no contêiner. Se você quiser continuar usando o contêiner, mas não precisar mais desses arquivos de suporte, exclua a `.c9` pasta do diretório no contêiner que você especificou AWS Cloud9 para começar após o login. Por exemplo, se o diretório for `~`, execute o comando ** `rm` ** com a opção ** `-r` **, da seguinte forma.
```
sudo rm -r ~/.c9
```
### Etapa 6.3: Remover os arquivos de suporte do Docker na instância
Se não quiser mais manter o contêiner do Docker, a imagem do Docker e o Docker na instância do Amazon EC2, mas quiser manter a instância, você pode remover esses arquivos de suporte do Docker da seguinte forma:
1. Remova o contêiner do Docker na instância. Para fazer isso, execute o comando ** `docker` ** na instância com as ações de interrupção ** `stop` ** e ** `rm` **, e o nome legível do contêiner.
```
sudo docker stop cloud9
sudo docker rm cloud9
```
1. Remova a imagem do Docker na instância. Para fazer isso, execute o comando ** `docker` ** na instância com a ação ** `image rm` ** e a tag da imagem.
```
sudo docker image rm cloud9-image:latest
```
1. Remova todos os arquivos de suporte do Docker adicionais que ainda possam existir. Para fazer isso, execute o comando ** `docker` ** na instância com a ação ** `system prune` **.
```
sudo docker system prune -a
```
1. Desinstale o Docker. Para fazer isso, execute o comando ** `yum` ** na instância com a ação ** `remove` **, especificando o pacote ** `docker` ** a ser desinstalado.
Para Amazon Linux:
```
sudo yum -y remove docker
```
Para Ubuntu Server:
```
sudo apt -y remove docker
```
Também é possível remover os arquivos `Dockerfile` e `authorized_keys` criados anteriormente. Por exemplo, execute o comando ** `rm` ** na instância.
```
sudo rm /tmp/Dockerfile
sudo rm /tmp/authorized_keys
```
### Etapa 6.4: Encerrar a instância
Para encerrar a instância do Amazon EC2, consulte [Encerramento de instâncias do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) no *Manual do usuário do Amazon EC2*.
## Tutoriais relacionados
+ [Introdução ao](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html) *Guia AWS RoboMaker do AWS RoboMaker Desenvolvedor*. Este tutorial é usado AWS Cloud9 para modificar, criar e agrupar um aplicativo de robô de amostra.