AWS Cloud9 ya no está disponible para nuevos clientes. Los clientes existentes de AWS Cloud9 pueden seguir utilizando el servicio con normalidad. [Más información](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutoriales para AWS Cloud9
¿Eres nuevo en AWS Cloud9? Haga un recorrido por el IDE en [Introducción: tutoriales básicos](tutorials-basic.md).
Experimenta con estos tutoriales y ejemplos de código para aumentar tus conocimientos y tu confianza en el uso AWS Cloud9 de varios lenguajes y AWS servicios de programación.
**Topics**
+ [AWS CLI y un tutorial de aws-shell](sample-aws-cli.md)
+ [AWS CodeCommit tutorial](sample-codecommit.md)
+ [Tutorial de Amazon DynamoDB](sample-dynamodb.md)
+ [AWS CDK tutorial](sample-cdk.md)
+ [Tutorial LAMP](sample-lamp.md)
+ [WordPress tutorial](sample-wordpress.md)
+ [Tutorial de Java](sample-java.md)
+ [Tutorial de C\$1\$1](sample-cplusplus.md)
+ [Tutorial de Python](sample-python.md)
+ [Tutorial de .NET](sample-dotnetcore.md)
+ [Tutorial de Node.js](sample-nodejs.md)
+ [Tutorial PHP](sample-php.md)
+ [Ruby](tutorial-ruby.md)
+ [Tutorial de Go](sample-go.md)
+ [TypeScript tutorial](sample-typescript.md)
+ [Tutorial de Docker](sample-docker.md)
+ [Tutoriales relacionados](#samples-additonal)
# AWS CLI y tutorial de aws-shell para AWS Cloud9
El siguiente tutorial le permite configurar el AWS Command Line Interface (AWS CLI), el aws-shell o ambos en un AWS Cloud9 entorno de desarrollo. AWS CLI Tanto el aws-shell como el aws-shell son herramientas unificadas que proporcionan una interfaz coherente para interactuar con todas las partes de. AWS Puede utilizar el comando AWS CLI en lugar del Consola de administración de AWS para ejecutar rápidamente los comandos con los que interactuar AWS, y algunos de estos comandos se pueden ejecutar con el comando AWS CLI o, alternativamente, utilizarlos. AWS CloudShell
Para obtener más información sobre el AWS CLI, consulte la [Guía AWS Command Line Interface del usuario](https://docs.aws.amazon.com/cli/latest/userguide/). Para el aws-shell, consulte los recursos siguientes:
+ [aws-shell en el sitio](https://github.com/awslabs/aws-shell) web GitHub
+ [aws-shell](https://pypi.python.org/pypi/aws-shell) en el sitio web de pip
Para obtener una lista de los comandos que puede ejecutar con los AWS CLI que interactuar AWS, consulte la Referencia de [AWS CLI comandos](https://docs.aws.amazon.com/cli/latest/reference/). Puede usar los mismos comandos con ellos AWS CloudShell, excepto que puede iniciar comandos sin el `aws` prefijo.
La creación de este ejemplo podría generar cargos en su AWS cuenta. Entre estos se incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-aws-cli-prereqs)
+ [Paso 1: Instale el AWS CLI, el aws-shell o ambos en su entorno](#sample-aws-cli-install)
+ [Paso 2: Configurar la administración de credenciales en su entorno](#sample-aws-cli-creds)
+ [Paso 3: Ejecute comandos básicos con AWS CLI o con el aws-shell de su entorno](#sample-aws-cli-run)
+ [Paso 4: Limpiar](#sample-aws-cli-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instale el AWS CLI, el aws-shell o ambos en su entorno
En este paso, utiliza el AWS Cloud9 IDE para instalar el AWS CLI, el aws-shell o ambos en su entorno, de modo que pueda ejecutar comandos con los que interactuar. AWS
Si utiliza un entorno de desarrollo AWS Cloud9 EC2 y solo quiere utilizar el AWS CLI, puede pasar directamente a. [Paso 3: Ejecute comandos básicos con AWS CLI o con el aws-shell de su entorno](#sample-aws-cli-run) Esto se debe a que ya AWS CLI está instalado en un entorno EC2 y ya hay un conjunto de credenciales de AWS acceso configurado en el entorno. Para obtener más información, consulte [AWS credenciales temporales gestionadas](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Si no utiliza un entorno de EC2, siga estos pasos para instalar AWS CLI:
1. Con el entorno abierto, compruebe en el IDE si ya AWS CLI está instalado. En el terminal, ejecute el comando ** `aws --version` **. (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**). Si AWS CLI está instalado, se muestra el número de versión, con información como los números de versión de Python y el número de versión del sistema operativo de su instancia de Amazon EC2 o de su propio servidor. Si AWS CLI está instalado, pase a[Paso 2: Configurar la administración de credenciales en su entorno](#sample-aws-cli-creds).
1. Para instalarlo AWS CLI, consulte [Instalación del AWS Command Line Interface en la](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *Guía del AWS Command Line Interface usuario*. Por ejemplo, en el caso de un entorno de EC2 que ejecute Amazon Linux, ejecute estos tres comandos en el terminal, de uno en uno, para instalar 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.
```
En el caso de un entorno de EC2 que ejecute Ubuntu Server, ejecute estos tres comandos en el terminal en su lugar, de uno en uno, para instalar 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.
```
Si desea instalar el aws-shell, siga estos pasos:
1. Con el entorno abierto, en el IDE, verifique si aws-shell ya está instalado. En el terminal, ejecute el comando ** `aws-shell` **. (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**). Si el aws-shell está instalado, se muestra el símbolo de `aws>`. Si el aws-shell está instalado, continúe en [Paso 2: Configurar la administración de credenciales en su entorno](#sample-aws-cli-creds).
1. Para instalar el aws-shell, utilice pip. Para ello, debe tener instalado Python.
Para verificar si Python ya está instalado (y para instalarlo si es necesario), siga las instrucciones de [Paso 1: Instalar Python](sample-python.md#sample-python-install) en la *Muestra de Python* y, a continuación, vuelva a este tema.
Para comprobar si pip ya está instalado, en el terminal, ejecute el comando ** `pip --version` **. Si lo está, aparece el número de versión. Si pip no está instalado, instálelo ejecutando estos tres comandos, de uno en uno, en el 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 utilizar pip para instalar el aws-shell, ejecute el siguiente comando.
```
sudo pip install aws-shell
```
## Paso 2: Configurar la administración de credenciales en su entorno
Cada vez que utilice el aws-shell AWS CLI o el aws-shell para llamar a un AWS servicio, debe proporcionar un conjunto de credenciales con la llamada. Estas credenciales determinan si el aws-shell AWS CLI o el aws-shell tienen los permisos adecuados para realizar esa llamada. Si las credenciales no cubren los permisos adecuados, la llamada no se realizará correctamente.
Si utiliza un entorno de desarrollo AWS Cloud9 EC2, puede pasar directamente a. [Paso 3: Ejecute comandos básicos con AWS CLI o con el aws-shell de su entorno](#sample-aws-cli-run) Esto se debe a que las credenciales ya están configuradas en un entorno de EC2. Para obtener más información, consulte [AWS credenciales temporales gestionadas](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Si no utiliza un entorno de EC2, debe almacenar manualmente sus credenciales en el entorno. Para ello, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
## Paso 3: Ejecute comandos básicos con AWS CLI o con el aws-shell de su entorno
En este paso, utiliza el AWS CLI o el aws-shell de su entorno para crear un bucket en Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket.
1. Si desea utilizar el aws-shell pero aún no lo ha iniciado, inicie el aws-shell ejecutando el comando `aws-shell`. Se muestra el símbolo `aws>`.
1. Crear un bucket. Ejecute el **`aws s3 mb`**`s3 mb`****comando AWS CLI o con el aws-shell e indique el nombre del bucket que desea crear. En este ejemplo, utilizamos un bucket llamado`cloud9-123456789012-bucket`, donde `123456789012` está tu ID de AWS cuenta. Si usa otro nombre, sustitúyalo en todo este paso.
```
aws s3 mb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 mb s3://cloud9-123456789012-bucket # For the aws-shell.
```
**nota**
Los nombres de los buckets deben ser únicos en toda tu cuenta AWS, no solo AWS en tu cuenta. El nombre del bucket sugerido anterior puede ayudarle a crear un nombre de bucket único. Si recibe un mensaje que contiene el error `BucketAlreadyExists`, debe ejecutar el comando de nuevo con otro nombre de bucket.
1. Enumere los buckets disponibles. Ejecute el **`aws s3 ls`**comando con AWS CLI o el **`s3 ls`**comando con aws-shell. Se muestra una lista de los buckets disponibles.
1. Elimine el bucket . Ejecute el **`aws s3 rb`**comando con el AWS CLI o el **`s3 rb`**comando con el aws-shell e indique el nombre del bucket que se va a eliminar.
```
aws s3 rb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 rb s3://cloud9-123456789012-bucket # For the aws-shell.
```
Para confirmar si el bucket se ha eliminado, vuelva a ejecutar el **`aws s3 ls`**comando con el AWS CLI o vuelva a ejecutar el **`s3 ls`**comando con el aws-shell. El nombre del bucket que se haya eliminado no debería aparecer ya en la lista.
**nota**
No es necesario eliminar el bucket si desea seguir utilizándolo. Para obtener más información, consulte [Add an Object to a Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) (Adición de un objeto a un bucket) en la *Guía del usuario de Amazon Simple Storage Service*. Consulte también [Comandos de S3](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html.html) en *Referencia de los comandos de AWS CLI *. (Recuerda que si no eliminas el depósito, es posible que se produzcan cargos continuos en tu AWS cuenta).
Para seguir experimentando con el AWS CLI, consulte [Trabajar con Amazon Web Services](https://docs.aws.amazon.com/cli/latest/userguide/chap-working-with-services.html) en la *Guía del AWS Command Line Interface usuario* y en la [Referencia de AWS CLI comandos](https://docs.aws.amazon.com/cli/latest/reference/). Para continuar experimentando con aws-shell, consulte [Referencia de los comandos de AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/) y tenga en cuenta que debe iniciar los comandos sin el prefijo `aws`.
## Paso 4: Limpiar
Si utiliza el shell de AWS, puede dejar de utilizarlo ejecutando el comando ** `.exit` ** o ** `.quit` **.
Para evitar que se sigan realizando cargos en tu AWS cuenta una vez que hayas terminado de usar este ejemplo, debes eliminar el entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# AWS CodeCommit tutorial para AWS Cloud9
Puede utilizar el AWS CodeCommit tutorial para configurar un entorno de AWS Cloud9 desarrollo en el que interactuar con un repositorio de código remoto CodeCommit. CodeCommit es un servicio de control de código fuente que puede utilizar para almacenar y gestionar de forma privada Git los repositorios de. Nube de AWS Para obtener más información al respecto CodeCommit, consulte la [Guía del AWS CodeCommit usuario](https://docs.aws.amazon.com/codecommit/latest/userguide/).
Si sigue este tutorial y crea este ejemplo, es posible que se le cobren gastos Cuenta de AWS. Estos incluyen posibles cargos por servicios como Amazon EC2 y. CodeCommit Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de AWS CodeCommit](https://aws.amazon.com/codecommit/pricing/).
+ [Requisitos previos](#sample-codecommit-prereqs)
+ [Paso 1: configurar el grupo de IAM con los permisos de acceso necesarios](#sample-codecommit-permissions)
+ [Paso 2: Crear un repositorio en AWS CodeCommit](#sample-codecommit-create-repo)
+ [Paso 3: conectar el entorno con el repositorio remoto](#sample-codecommit-connect-repo)
+ [Paso 4: clonar el repositorio remoto en su entorno](#sample-codecommit-clone-repo)
+ [Paso 5: añadir archivos al repositorio](#sample-codecommit-add-files)
+ [Paso 6: limpiar](#sample-codecommit-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: configurar el grupo de IAM con los permisos de acceso necesarios
Suponga que sus AWS credenciales están asociadas a un usuario administrador y desea utilizar ese usuario para trabajar con él. A CodeCommit continuación, vaya al [paso 2: Crear un repositorio en AWS CodeCommit](#sample-codecommit-create-repo). Cuenta de AWS
Puede completar este paso con la [Consola de administración de AWS](#sample-codecommit-permissions-console) o con la [interfaz de línea de comandos de AWS (AWS CLI)](#sample-codecommit-permissions-cli).
### Configurar el grupo de IAM con los permisos de acceso necesarios usando la consola
1. Inicie sesión en Consola de administración de AWS, si aún no lo ha hecho.
En este paso, le recomendamos que inicie sesión con las credenciales de un usuario administrador en la Cuenta de AWS. Si no puede hacerlo, consulte con el administrador de la Cuenta de AWS .
1. Abra la consola de IAM. Para ello, en la barra de navegación de la consola, elija **Services** (Servicios). A continuación, elija **IAM**.
1. Elija **Groups** (Grupos).
1. Elija el nombre del grupo.
1. En la pestaña **Permissions** (Permisos), en **Managed Policies** (Políticas administradas), elija **Attach Policy** (Adjuntar política).
1. En la lista con los nombres de las políticas, seleccione una de las siguientes casillas:
+ Seleccione esta opción **AWSCodeCommitPowerUser**para acceder a todas las funciones CodeCommit y a los recursos relacionados con el repositorio. Sin embargo, esto no te permite eliminar CodeCommit repositorios ni crear o eliminar recursos relacionados con los repositorios en otros, Servicios de AWS como Amazon Events. CloudWatch
+ Seleccione esta opción **AWSCodeCommitFullAccess**para tener el control total sobre los CodeCommit repositorios y los recursos relacionados de. Cuenta de AWS Esto incluye la capacidad de eliminar repositorios.
Si no ve ninguno de los nombres de política en la lista, escriba los nombres de la políticas en el cuadro **Filter** (Filtrar) para mostrarlos.
1. Seleccione **Asociar política**.
Para ver la lista de permisos de acceso que estas políticas AWS administradas otorgan a un grupo, consulte [Políticas AWS administradas (predefinidas) AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) en la *Guía del AWS CodeCommit usuario*.
Continúe con el [paso 2: Crear un repositorio en AWS CodeCommit](#sample-codecommit-create-repo).
### Configure su grupo de IAM con los permisos de acceso necesarios mediante el AWS CLI
Ejecute el `attach-group-policy` comando IAM y especifique el nombre del grupo y el nombre de recurso de Amazon (ARN) de AWS la política gestionada que describe los permisos de acceso necesarios. La sintaxis es la siguiente.
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
En el comando anterior, reemplace `MyGroup` por el nombre del grupo. `POLICY_ARN`Sustitúyalo por el ARN de la política AWS gestionada:
+ `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser`para acceder a todas las funciones CodeCommit y los recursos relacionados con el repositorio. Sin embargo, no te permite eliminar CodeCommit repositorios ni crear o eliminar recursos relacionados con los repositorios en otros, Servicios de AWS como Amazon Events. CloudWatch
+ `arn:aws:iam::aws:policy/AWSCodeCommitFullAccess`para tener un control total sobre los CodeCommit repositorios y los recursos relacionados en. Cuenta de AWS Esto incluye la capacidad de eliminar repositorios.
Para ver la lista de permisos de acceso que estas políticas AWS administradas otorgan a un grupo, consulte [Políticas AWS administradas (predefinidas) AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies) en la *Guía del AWS CodeCommit usuario*.
## Paso 2: Crea un repositorio en CodeCommit
En este paso, se crea un repositorio de código remoto CodeCommit mediante la CodeCommit consola.
Si ya tiene un CodeCommit repositorio, vaya al [paso 3: Conectar su entorno al repositorio remoto](#sample-codecommit-connect-repo).
Puede completar este paso con la [Consola de administración de AWS](#sample-codecommit-create-repo-console) o con la [interfaz de línea de comandos de AWS (AWS CLI)](#sample-codecommit-create-repo-cli).
### Cree un repositorio CodeCommit mediante la consola
1. Supongamos que ha iniciado sesión Consola de administración de AWS como usuario administrador en el paso anterior y no desea utilizar el usuario administrador para crear el repositorio. A continuación, cierre sesión en Consola de administración de AWS.
1. Abre la CodeCommit consola, en [https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit).
1. En la barra de navegación de la consola, utilice el selector de regiones para elegir la Región de AWS en la que desea crear el repositorio (por ejemplo, **US East (Ohio)** [Este de EE. UU [Ohio]]).
1. Si aparece una página de bienvenida, elija **Get Started Now**. Si no, elija **Create repository (Crear repositorio)**.
1. En la página **Create repository** (Crear repositorio), en **Repository name** (Nombre del repositorio), escriba un nombre para el repositorio (por ejemplo, `MyDemoCloud9Repo`). Si elige otro nombre, sustitúyalo en todo este ejemplo.
1. (Opcional) En **Description** (Descripción), escriba un breve texto sobre el repositorio. Por ejemplo, puede introducir: `This is a demonstration repository for the AWS Cloud9 sample.`
1. Elija **Create repository**. Se muestra un panel **Connect to your repository (Conectar con el repositorio)**. Seleccione **Close (Cerrar)**, ya que se conectará a su repositorio de una forma diferente más adelante en este tema.
Salte al [Paso 3: Conectar el entorno con el repositorio remoto](#sample-codecommit-connect-repo).
### Cree un repositorio utilizando CodeCommit AWS CLI
Ejecute el comando AWS CodeCommit `create-repository`. Especifique el nombre del repositorio, una descripción opcional y el elemento en el Región de AWS que se va a crear el repositorio.
```
aws codecommit create-repository --repository-name MyDemoCloud9Repo --repository-description "This is a demonstration repository for the AWS Cloud9 sample." --region us-east-2
```
En el comando anterior, sustituya `us-east-2` por el ID de la Región de AWS en la que se creará el repositorio. Para obtener una lista de las regiones compatibles, consulte [AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region) en la *Referencia general de Amazon Web Services*.
Si decide usar otro nombre para el repositorio sustitúyalo en todo este ejemplo.
## Paso 3: conectar el entorno con el repositorio remoto
En este paso, utiliza el AWS Cloud9 IDE para conectarse al CodeCommit repositorio que creó o identificó en el paso anterior.
**nota**
Si prefiere trabajar con Git a través de una interfaz visual, puede clonar el repositorio remoto. A continuación, puede añadir archivos mediante la función del [panel de Git](source-control-gitpanel.md) que está disponible en el IDE.
Complete uno de los siguientes conjuntos de procedimientos en función del tipo de entorno de desarrollo de AWS Cloud9 que tenga.
****
| **Tipo de entorno** | **Siga estos procedimientos** |
| --- | --- |
| Entorno de EC2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/sample-codecommit.html) |
| Entorno de SSH | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/sample-codecommit.html) |
## Paso 4: clonar el repositorio remoto en su entorno
En este paso, utilizará el AWS Cloud9 IDE para clonar el repositorio remoto CodeCommit en su entorno.
Para clonar el repositorio, ejecute el comando **`git clone`**. Reemplace `CLONE_URL` por la URL de clonación del repositorio.
```
git clone CLONE_URL
```
Para un entorno de EC2, se proporciona una URL de clonación HTTPS que comienza por `https://`. Para un entorno de SSH, se proporciona una URL de clonación SSH que comienza por `ssh://`.
Para obtener la URL de clonación completa del repositorio, consulte [Uso de la AWS CodeCommit consola para ver los detalles del repositorio](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-view-repository-details.html#how-to-view-repository-details-console) en la *Guía del AWS CodeCommit usuario*.
Si su repositorio no tiene ningún archivo, se muestra un mensaje de advertencia, por ejemplo, `You appear to have cloned an empty repository.` Este es el comportamiento esperado. Lo veremos más adelante.
## Paso 5: añadir archivos al repositorio
En este paso, se crean tres archivos simples en el repositorio clonado de su entorno de AWS Cloud9 . A continuación, añada los archivos al área provisional de Git de su repositorio clonado. Por último, confirmas los archivos preconfigurados e insertas la confirmación en tu repositorio remoto CodeCommit.
Si el repositorio clonado ya tiene archivos, ha terminado y puede ignorar el resto de esta muestra.
**Para añadir archivos al repositorio**
1. Cree un archivo nuevo. En la barra de menús, elija **File** (Archivo), **New File** (Archivo nuevo).
1. Introduzca el siguiente contenido en el archivo y, a continuación, seleccione **Archivo** y **Guardar** para guardar el archivo como se `bird.txt` encuentra en el `MyDemoCloud9Repo` directorio de su AWS Cloud9 entorno.
```
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 guarda el archivo en el directorio correcto, en el cuadro de diálogo **Save As** (Guardar como), elija la carpeta `MyDemoCloud9Repo`. A continuación, asegúrese de que en **Folder** (Carpeta) se muestre `/MyDemoCloud9Repo`.
1. Cree dos archivos más, llamados `insect.txt` y `reptile.txt`, con el siguiente contenido. Guarde los archivos en el mismo directorio `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. En el terminal, ejecute el comando **`cd`** para cambiar al directorio `MyDemoCloud9Repo`.
```
cd MyDemoCloud9Repo
```
1. Confirme que el archivo se ha guardado correctamente en el directorio `MyDemoCloud9Repo` ejecutando el comando **`git status`**. Los tres archivos se mostrarán como archivos sin seguimiento.
```
Untracked files:
(use "git add ..." to include in what will be committed)
bird.txt
insect.txt
reptile.txt
```
1. Añada los archivos al espacio provisional de Git ejecutando el comando **`git add`**.
```
git add --all
```
1. Confirme que los archivos se hayan añadido correctamente al espacio provisional de Git ejecutando el comando **`git status`** de nuevo. Los tres archivos aparecen ahora como cambios por confirmar.
```
Changes to be committed:
(use "git rm --cached ..." to unstage)
new file: bird.txt
new file: insect.txt
new file: reptile.txt
```
1. Confirme los archivos del espacio provisional ejecutando el comando **`git commit`**.
```
git commit -m "Added information about birds, insects, and reptiles."
```
1. Inserte la confirmación en su repositorio remoto CodeCommit ejecutando el **`git push`**comando.
```
git push -u origin master
```
1. Confirme si los archivos se han enviado correctamente. Abre la CodeCommit consola, si aún no está abierta, en [https://console.aws.amazon.com/codecommit.](https://console.aws.amazon.com/codecommit)
1. En la barra de navegación superior, cerca del borde derecho, elige el Región de AWS lugar donde has creado el repositorio (por ejemplo, **US East (Ohio))**.
1. En la página del **panel** de control, selecciona **MyDemoCloud9Repo**. Se muestran los tres archivos.
*Para seguir experimentando con tu CodeCommit repositorio, consulta [Explorar el contenido de tu repositorio](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse) en la Guía del AWS CodeCommit usuario.*
Si eres nuevo en el repositorio Git y no quieres estropearlo, prueba con un CodeCommit repositorio de muestra Git en el sitio Git web de [Try](https://try.github.io/).
## Paso 6: limpiar
Para evitar que se te siga cobrando una Cuenta de AWS vez que hayas terminado de usar este ejemplo, elimina el CodeCommit repositorio. Para obtener instrucciones, consulte [Eliminar un AWS CodeCommit repositorio](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html) en la *Guía del AWS CodeCommit usuario*.
Asegúrese también de eliminar el entorno. Para obtener instrucciones, consulte la sección sobre [eliminación de entornos](delete-environment.md).
# Tutorial de Amazon DynamoDB para AWS Cloud9
Este tutorial le permite configurar un entorno de AWS Cloud9 desarrollo para trabajar con Amazon DynamoDB.
DynamoDB es una base de datos NoSQL completamente administrada. Puede utilizar DynamoDB para crear una tabla de base de datos capaz de almacenar y recuperar cualquier cantidad de datos, así como de atender cualquier nivel de tráfico de solicitudes. DynamoDB distribuye automáticamente los datos y el tráfico de la tabla entre un número de servidores suficiente como para administrar la capacidad de solicitudes especificada y la cantidad de datos almacenados, manteniendo al mismo tiempo un rendimiento uniforme y rápido. Para obtener más información, consulte [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) en el sitio web. AWS
La creación de este ejemplo puede conllevar cargos a su cuenta. AWS Estos incluyen posibles cargos por servicios como Amazon EC2 y DynamoDB. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Para obtener información sobre ofertas AWS de bases de datos adicionales, consulte [Amazon Relational Database Service (RDS](https://aws.amazon.com/rds/)) [ ElastiCache,](https://aws.amazon.com/elasticache/) [Amazon y Amazon Redshift](https://aws.amazon.com/redshift/) en el sitio web. AWS Consulte también [AWS Database Migration Service](https://aws.amazon.com/dms/) en el sitio web de AWS .
+ [Requisitos previos](#sample-dynamodb-prereqs)
+ [Paso 1: instalar y configurar la AWS CLI, el AWS CloudShell o ambos en el entorno](#sample-dynamodb-cli-setup)
+ [Paso 2: crear una tabla](#sample-dynamodb-create-table)
+ [Paso 3 agregar un elemento a la tabla](#sample-dynamodb-add-item)
+ [Paso 4: agregar varios elementos a la tabla](#sample-dynamodb-add-items)
+ [Paso 5: crear un índice secundario global](#sample-dynamodb-create-index)
+ [Paso 6: obtener elementos de la tabla](#sample-dynamodb-get-items)
+ [Paso 7: limpieza](#sample-dynamodb-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instale y configure el AWS CLI AWS CloudShell, el o ambos en su entorno
En este paso, utilizará el AWS Cloud9 IDE para instalar y configurar el entorno AWS CLI AWS CloudShell, o ambos, de forma que pueda ejecutar comandos para interactuar con DynamoDB. A continuación, utilice AWS CLI para ejecutar un comando de DynamoDB básico para probar la instalación y la configuración.
1. Para configurar la administración de credenciales AWS CloudShell e instalar el AWS CLI, el AWS CLI o ambos en su entorno AWS CloudShell, siga los pasos 1 y 2 del [AWS CLIAWS CloudShell ejemplo](sample-aws-cli.md) y y, a continuación, vuelva a este tema. Si ya instaló y configuró el AWS CLI AWS CloudShell, el o ambos en su entorno, no necesita volver a hacerlo.
1. Pruebe la instalación y la configuración del AWS CLI aws-shell o de ambos ejecutando el **`list-tables`**comando DynamoDB desde una sesión de terminal de su entorno para enumerar las tablas de DynamoDB existentes, si las hubiera. Para comenzar una nueva sesión de terminal, en la barra de menús, seleccione **Windows (Ventanas)**, **New Terminal (Nuevo terminal)**.
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**nota**
En este ejemplo, si está utilizando el aws-shell, omita `aws` de cada comando que comience por `aws`. Para iniciar el shell de AWS, ejecute el comando ** `aws-shell` **. Para dejar de usar el shell de AWS, ejecute el comando ** `.exit` ** o ** `.quit` **.
Si este comando se ejecuta correctamente, genera una matriz `TableNames` que contiene una lista de tablas de DynamoDB existentes que es posible que ya tenga. Si no tiene aún tablas de DynamoDB, la matriz de `TableNames` estará vacía.
```
{
"TableNames": []
}
```
Si tiene cualquier tabla de DynamoDB, la matriz de `TableNames` contiene una lista de los nombres de las tablas.
## Paso 2: Crear una tabla
En este paso, se crea una tabla en DynamoDB y se especifica el nombre de la tabla, el diseño, la clave principal simple y la configuración de rendimiento de los datos.
Esta tabla de ejemplo, denominada `Weather`, contiene información acerca de las previsiones meteorológicas para algunas ciudades de Estados Unidos. La tabla contiene los siguientes tipos de información (en DynamoDB, cada fragmento de información se denomina *atributo*):
+ ID único y obligatorio de la ciudad (`CityID`)
+ Fecha de previsión obligatoria (`Date`)
+ Nombre de ciudad (`City`)
+ Nombre de estado (`State`)
+ Condiciones meteorológicas de la previsión (`Conditions`)
+ Temperaturas de la previsión (`Temperatures`)
+ Temperatura máxima de la previsión, en grados Fahrenheit (`HighF`)
+ Temperatura mínima de la previsión, en grados Fahrenheit (`LowF`)
Para crear la tabla, en una sesión de terminal en el AWS Cloud9 IDE, ejecute el 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
```
En este comando:
+ `--table-name` representa el nombre de la tabla (`Weather` en este ejemplo). Los nombres de las tablas deben ser únicos en cada AWS región de la cuenta. AWS
+ `--attribute-definitions` representa los atributos que se utilizan para identificar de forma única los elementos de la tabla. Cada uno de los elementos de esta tabla se identifica de forma única por medio de una combinación de un atributo `ID` numérico y un atributo `Date` representado como una cadena con formato ISO-8601.
+ `--key-schema` representa el esquema de claves de la tabla. Esta tabla tiene una clave principal compuesta de `CityID` y `Date`. Esto significa que cada uno de los elementos de la tabla debe tener un valor de atributo `CityID` y un valor de atributo `Date`, pero no puede haber dos elementos de la tabla que tengan el mismo valor de atributo `CityID` y valor de atributo `Date`.
+ `--provisioned-throughput` representa la capacidad de lectura-escritura de la tabla. DynamoDB permite hasta 5 lecturas de alta consistencia por segundo para elementos de hasta 4 KB de tamaño o hasta 5 lecturas eventualmente consistentes por segundo para los elementos de hasta 4 KB de tamaño. DynamoDB también permite hasta 5 escrituras por segundo para los elementos con un tamaño de hasta 1 KB.
**nota**
Si se establece un mayor rendimiento aprovisionado, es posible que se apliquen cargos adicionales a tu AWS cuenta.
Para obtener más información acerca de este comando y otros comandos de DynamoDB, consulte [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html), en la *Referencia de comandos de AWS CLI *.
Si este comando se ejecuta correctamente, se muestra información resumida sobre la tabla nueva que se está creando. Para confirmar que la tabla se ha creado correctamente, ejecute el comando ** `describe-table` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Cuando la tabla se crea correctamente, el valor de `TableStatus` cambia de `CREATING` a `ACTIVE`. No siga realizando los pasos hasta que la tabla se haya creado correctamente.
## Paso 3: Agregar un elemento a la tabla
En este paso, se añade un elemento a la tabla que se acaba de crear.
1. Cree un archivo llamado `weather-item.json` con el siguiente contenido. Para crear un archivo nuevo, en la barra de menús, elija **File (Archivo)**, **New File (Nuevo archivo)**. Para guardar el archivo, elija **File (Archivo)**, **Save (Guardar)**.
```
{
"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" }
}
}
}
```
En este código, `N` representa un valor de atributo que es un número. `S` es un valor de atributo de cadena. `M` es un atributo de mapa, que es un conjunto de pares de atributo-valor. Debe especificar un tipo de datos del atributo siempre que trabaje con elementos. Para obtener tipos de datos de atributos disponibles adicionales, consulte [Tipos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) en la *Guía para desarrolladores de Amazon DynamoDB*.
1. Ejecute el comando ** `put-item` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`) y la ruta del elemento con formato JSON (`--item`).
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
Si el comando se ejecuta correctamente, no habrá errores y no aparecerá ningún mensaje de confirmación.
1. Para confirmar el contenido actual de la tabla, ejecute el comando ** `scan` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb scan --table-name Weather
```
Si el comando se ejecuta correctamente, aparece la información resumida sobre la tabla y el elemento que acaba de agregar.
## Paso 4: Agregar varios elementos a la tabla
En este paso, agregamos varios elementos más a la tabla `Weather`.
1. Cree un archivo llamado `more-weather-items.json` con el siguiente contenido.
```
{
"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" }
}
}
}
}
}
]
}
```
En este código, hay 8 objetos `Item` que definen los 8 elementos que se van a añadir a la tabla, de forma similar al elemento único que se ha definido en el paso anterior. Sin embargo, al ejecutar el comando ** `batch-write-item` ** de DynamoDB en el siguiente paso, debe proporcionar un objeto con formato JSON que incluya cada uno de los objetos `Item` en un objeto `PutRequest` contenedor. A continuación, debe incluir esos objetos `PutRequest` en una matriz principal que tenga el mismo nombre que la tabla.
1. Ejecute el comando ** `batch-write-item` ** de DynamoDB y especifique la ruta de los elementos con formato JSON que se van a agregar (`--request-items`).
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
Si el comando se ejecuta correctamente, se muestra el siguiente mensaje, que confirma que los elementos se han agregado correctamente.
```
{
"UnprocessedItems": {}
}
```
1. Para confirmar el contenido actual de la tabla, ejecute de nuevo el comando ** `scan` ** de DynamoDB.
```
aws dynamodb scan --table-name Weather
```
Si el comando se ejecuta correctamente, ahora se muestran 9 elementos.
## Paso 5: Crear un índice secundario global
La ejecución del comando ** `scan` ** de DynamoDB para obtener información sobre elementos puede ser lenta, especialmente cuando la tabla aumenta de tamaño o si el tipo de información que desea obtener es complejo. Puede crear uno o varios índices secundarios para acelerar las cosas y obtener información más fácilmente. En este paso, conocerá dos tipos de índices secundarios que DynamoDB admite para hacer precisamente eso. Se denominan *índice secundario local* e *índice secundario global*. A continuación, se crea un índice secundario global.
Para comprender estos tipos de índices secundarios, primero debe conocer las claves primarias, que identifican de forma única los elementos de una tabla. DynamoDB admite una *clave principal simple* o una *clave principal compuesta*. Una clave principal simple posee un único atributo y ese valor del atributo debe ser único para cada elemento de la tabla. Este atributo también se conoce como *clave de partición* (o un *atributo hash*), que DynamoDB puede utilizar para particionar elementos para que el acceso sea más rápido. Una tabla también puede tener una clave principal compuesta, que contiene dos atributos. El primer atributo es la clave de partición y el segundo es una *clave de ordenación* (también conocida como *atributo de rango*). En una tabla con una clave principal compuesta, puede haber dos elementos que tengan el mismo valor de clave de partición, pero no pueden tener también el mismo valor de clave de ordenación. La tabla `Weather` tiene una clave principal compuesta.
Un índice secundario local tiene la misma clave de partición que la propia tabla, pero este tipo de índice puede tener una clave de ordenación diferente. Un índice secundario global puede tener una clave de partición y una clave de ordenación que son diferentes a la tabla en sí.
Por ejemplo, ya puede utilizar la clave principal para obtener acceso a elementos `Weather` por `CityID`. Para obtener acceso a los elementos `Weather` por `State`, puede crear un índice secundario local que tenga una clave de partición de `CityID` (debe ser la misma que la tabla) y una clave de ordenación de `State`. Para obtener acceso a los elementos `Weather` por `City`, puede crear un índice secundario global que tenga una clave de partición de `City` y una clave de ordenación de `Date`.
Solo puede crear índices secundarios locales mientras está creando una tabla. Dado que la tabla `Weather` ya existe, no puede añadirle cualquier índice secundario local. Sin embargo, puede añadir índices secundarios globales. Añada uno ahora para practicar.
**nota**
La creación de índices secundarios puede producir cargos adicionales en su cuenta de AWS .
1. Cree un archivo llamado `weather-global-index.json` con el siguiente contenido.
```
[
{
"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
}
}
}
]
```
En este código:
+ El nombre del índice secundario global es `weather-global-index`.
+ El atributo `City` es la clave de partición (atributo hash) y el atributo `Date` es la clave de ordenación (atributo de rango).
+ `Projection` define los atributos que se van a recuperar de forma predeterminada (además del atributo hash y cualquier atributo de rango) por cada elemento que coincida con una búsqueda de tabla que utilice este índice. En este ejemplo, se recuperan los atributos`State`, `Conditions`, `HighF` (parte de `Temperatures`) y `LowF` ( `Temperatures`) (así como los atributos `City` y `Date`) para cada elemento coincidente.
+ Al igual que las tablas, un índice secundario global debe definir su configuración de desempeño aprovisionado.
+ La configuración de `IndexName`, `KeySchema`, `Projection` y `ProvisionedThroughput` debe estar incluida en un objeto `Create`, que define el índice secundario global que se va a crear al ejecutar el comando **`update-table`** de DynamoDB en el siguiente paso.
1. Ejecute el comando ** `update-table` ** de 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
```
En este comando:
+ `--table-name` es el nombre de la tabla que se va a actualizar.
+ `--attribute-definitions` son los atributos que se van a incluir en el índice. La clave de partición siempre aparece primero y cualquier clave de ordenación aparece siempre en segundo lugar.
+ `--global-secondary-index-updates` es la ruta al archivo que define el índice secundario global.
Si este comando se ejecuta correctamente, se muestra información resumida sobre el nuevo índice secundario global que se está creando. Para confirmar que el índice secundario global se ha creado correctamente, ejecute el comando ** `describe-table` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Cuando el índice secundario global se haya creado correctamente, el valor de `TableStatus` cambia de `UPDATING` a `ACTIVE` y el valor de `IndexStatus` cambia de `CREATING` a `ACTIVE`. No siga realizando los pasos hasta que el índice secundario global se haya creado correctamente. Esto puede tardar varios minutos.
## Paso 6: Obtener elementos de la tabla
Existen muchas formas de obtener elementos de las tablas. En este paso, se obtienen elementos mediante la clave principal de la tabla, mediante otros atributos de la tabla y utilizando el índice secundario global.
### Para obtener un solo elemento de una tabla en función del valor de la clave principal del elemento
Si conoce el valor de la clave principal del elemento, puede obtener el elemento coincidente ejecutando el comando ** `get-item` **, ** `scan` ** o ** `query` ** de DynamoDB. A continuación, se muestran las principales diferencias en estos comandos:
+ ** `get-item` ** devuelve un conjunto de atributos del elemento con la clave principal especificada.
+ ** `scan` ** devuelve uno o más elementos y atributos de elementos obteniendo acceso a todos los elementos de una tabla o un índice secundario.
+ ** `query` ** busca elementos según los valores de clave principal. Puede consultar cualquier tabla o índice secundario que cuente con una clave principal compuesta (una clave de partición y una clave de ordenación).
En este ejemplo, así es cómo se utiliza cada uno de estos comandos para obtener el elemento que contiene el valor del atributo `CityID` de `1` y el valor del atributo `Date` de `2017-04-12`.
1. Para ejecutar el comando** `get-item` ** de DynamoDB, especifique el nombre de la tabla (`--table-name`), el valor de clave principal (`--key`) y los valores de los atributos del elemento que se va a mostrar (`--projection-expression`). Dado que `Date` es una palabra clave reservada en DynamoDB, también debe proporcionar un alias para el valor del atributo `Date` (`--expression-attribute-names`). (`State` también es una palabra clave reservada, por lo que verá un alias proporcionado para este valor en pasos 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" }'
```
En este y otros comandos, para ver todos los atributos del elemento, no incluya `--projection-expression`. En este ejemplo, dado que no está incluyendo `--projection-expression`, tampoco es necesario incluir `--expression-attribute-names`.
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. Para ejecutar el comando ** `scan` ** de DynamoDB, especifique:
+ El nombre de la tabla (`--table-name`).
+ La búsqueda que se va a realizar (`--filter-expression`).
+ Los criterios de búsqueda que se van a utilizar (`--expression-attribute-values`).
+ Los tipos de atributos que se van a mostrar del elemento coincidente (`--select`).
+ Los valores de atributos del elemento que se va a mostrar (`--projection-expression`).
+ Si alguno de los atributos utiliza palabras reservadas de DynamoDB, los alias de esos 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 ejecutar el comando ** `query` ** de DynamoDB, especifique:
+ El nombre de la tabla (`--table-name`).
+ La búsqueda que se va a realizar (`--key-condition-expression`).
+ Los valores de los atributos que se van a utilizar en la búsqueda (`--expression-attribute-values`).
+ Los tipos de atributos que se van a mostrar del elemento coincidente (`--select`).
+ Los valores de atributos del elemento que se va a mostrar (`--projection-expression`).
+ Si alguno de los atributos utiliza palabras reservadas de DynamoDB, los alias de esos 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" }'
```
Fíjese en que el comando ** `scan` ** ha tenido que analizar los 9 elementos para obtener el resultado, mientras que el comando ** `query` ** solo ha tenido que analizar 1 elemento.
### Para obtener varios elementos de una tabla en función de los valores de la clave principal de los elementos
Si conoce los valores de la clave principal de los elementos, puede obtener los elementos coincidentes ejecutando el comando ** `batch-get-item` ** de DynamoDB. En este ejemplo, se muestra cómo se obtienen los elementos que contienen el valor del atributo `CityID` de `3` y los valores del atributo `Date` de `2017-04-13` o `2017-04-14`.
Ejecute el comando ** `batch-get-item` ** de DynamoDB y especifique la ruta a un archivo que describa los elementos que se van a obtener (`--request-items`).
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
Para este ejemplo, el código del archivo `batch-get-item.json` especifica que se deben buscar en la tabla `Weather` los elementos con un `CityID` de `3` y un `Date` de `2017-04-13` o `2017-04-14`. Para cada elemento encontrado, se muestran los valores de atributo de `City``State`, `Date` y `HighF` (parte de `Temperatures`), si existen.
```
{
"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 obtener todos los elementos coincidentes de una tabla
Si conoce algo sobre los valores de los atributos de la tabla, puede obtener los elementos coincidentes mediante la ejecución del comando ** `scan` ** de DynamoDB. En este ejemplo, se muestra cómo se obtienen las fechas cuando el valor del atributo `Conditions` contiene `Sunny` y el valor del atributo `HighF` (parte de `Temperatures`) es mayor que `53`.
Especifique lo siguiente para ejecutar el comando ** `scan` ** de DynamoDB:
+ El nombre de la tabla (`--table-name`).
+ La búsqueda que se va a realizar (`--filter-expression`).
+ Los criterios de búsqueda que se van a utilizar (`--expression-attribute-values`).
+ Los tipos de atributos que se van a mostrar del elemento coincidente (`--select`).
+ Los valores de atributos del elemento que se va a mostrar (`--projection-expression`).
+ Si alguno de los atributos utiliza palabras reservadas de DynamoDB, los alias de esos 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 obtener todos los elementos coincidentes de un índice secundario global
Para realizar una búsqueda mediante un índice secundario global, utilice el comando ** `query` ** de DynamoDB. En este ejemplo, se muestra cómo se utiliza el índice secundario `weather-global-index` para obtener las condiciones de la previsión en ciudades con el nombre `Portland` para las fechas `2017-04-13` y `2017-04-14`.
Especifique lo siguiente para ejecutar el comando ** `query` ** de DynamoDB:
+ El nombre de la tabla (`--table-name`).
+ El nombre del índice secundario global (`--index-name`).
+ La búsqueda que se va a realizar (`--key-condition-expression`).
+ Los valores de los atributos que se van a utilizar en la búsqueda (`--expression-attribute-values`).
+ Los tipos de atributos que se van a mostrar del elemento coincidente (`--select`).
+ Si alguno de los atributos utiliza palabras reservadas de DynamoDB, los alias de esos 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" }'
```
## Paso 7: limpiar
Para evitar que se sigan cobrando en tu AWS cuenta una vez que hayas terminado de usar este ejemplo, debes eliminar la tabla. Al eliminar la tabla, también se elimina el índice secundario global. También debe eliminar su entorno.
Para eliminar la tabla, ejecute el comando ** `delete-table` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb delete-table --table-name Weather
```
Si el comando se ejecuta correctamente, se muestra información sobre la tabla, incluido el valor de `TableStatus` de `DELETING`.
Para confirmar que la tabla se ha eliminado correctamente, ejecute el comando ** `describe-table` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Si la tabla se elimina correctamente, se muestra un mensaje que contiene la frase `Requested resource not found`.
Para eliminar su entorno, consulte [Eliminación de entornos](delete-environment.md).
# AWS CDK tutorial para AWS Cloud9
Este tutorial le muestra cómo trabajar con ellos AWS Cloud Development Kit (AWS CDK) en un entorno de AWS Cloud9 desarrollo. AWS CDK Se trata de un conjunto de herramientas y bibliotecas de software que los desarrolladores pueden utilizar para modelar los componentes de la AWS infraestructura como código.
AWS CDK Incluye la biblioteca AWS Construct, que puede utilizar para resolver rápidamente muchas tareas AWS. Por ejemplo, puede utilizar la construcción `Fleet` para implementar código de forma completa y segura en una flota de hosts. Puede crear sus propias construcciones para crear modelos de diversos elementos de sus arquitecturas, compartirlos con otras personas o publicarlos en la comunidad. Para obtener más información, consulte la [Guía del desarrollador del kit de desarrollo de la nube de AWS](https://docs.aws.amazon.com/cdk/v2/guide/home.html).
El uso de este tutorial y la creación de esta muestra pueden generar cargos en su cuenta de AWS . Entre estos se incluyen posibles cargos por servicios como Amazon EC2, Amazon SNS y Amazon SQS. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/), [Precios de Amazon SNS](https://aws.amazon.com/sns/pricing/) y [Precios de Amazon SQS](https://aws.amazon.com/sqs/pricing/).
**Topics**
+ [Requisitos previos](#sample-cdk-prereqs)
+ [Paso 1: Instalar las herramientas necesarias](#sample-cdk-install)
+ [Paso 2: Agregar el código](#sample-cdk-code)
+ [Paso 3: Ejecutar el código](#sample-cdk-run)
+ [Paso 4: Limpiar](#sample-cdk-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar las herramientas necesarias
En este paso, instalará en su entorno todas las herramientas necesarias AWS CDK para ejecutar un ejemplo escrito en el lenguaje de TypeScript programación.
1. [Node Version Manager](#sample-cdk-install-nvm) o **`nvm`**, que se utiliza para instalar Node.js más adelante.
1. [Node.js](#sample-cdk-install-nodejs), que se requiere en el ejemplo y contiene Node Package Manager, o bien **`npm`**, que se utiliza para la instalación TypeScript y versiones AWS CDK posteriores.
1. [TypeScript](#sample-cdk-install-typescript), que se requiere en este ejemplo. ( AWS CDK También es compatible con varios otros lenguajes de programación).
1. [AWS CDK](#sample-cdk-install-cdk).
### Paso 1.1: Instalar Node Version Manager (nvm)
1. En una sesión terminal en el AWS Cloud9 IDE, asegúrese de que estén instaladas las últimas actualizaciones de seguridad y correcciones de errores. Para ello, ejecute el comando ** `yum update` ** (para Amazon Linux) o ** `apt update` ** (para Ubuntu Server). (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**).
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Confirme si **`nvm`** ya está instalado. Para ello, ejecute el comando **`nvm`** con la opción **`--version`**.
```
nvm --version
```
Si se ejecuta correctamente, el resultado contiene el número de versión de ** `nvm` **, en cuyo caso puede ir directamente a [Paso 1.2: Instalar Node.js](#sample-cdk-install-nodejs).
1. Descargue e instale **`nvm`**. Para ello, ejecute el script de instalación. En este ejemplo, la versión instalada es la 0.33.0, pero puede consultar la última versión de **`nvm`** [aquí](https://github.com/nvm-sh/nvm#installing-and-updating).
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Comience a utilizar **`nvm`**. Puede cerrar la sesión del terminal e iniciarla de nuevo, o bien cargar el archivo `~/.bashrc` que contiene los comandos para cargar **`nvm`**.
```
. ~/.bashrc
```
### Paso 1.2: Instalar Node.js
1. Confirme si ya tiene instalado Node.js. Si es así, asegúrese de que la versión instalada es 16.17.0 o superior. **Este ejemplo se ha probado con Node.js 16.17.0.** Para verificarlo, con la sesión del terminal aún abierta en el IDE, ejecute el comando ** `node` ** con la opción ** `--version` **.
```
node --version
```
Si ha instalado Node.js, la salida contendrá el número de versión. Si el número de versión es 16.17.0, vaya directamente a [Paso 1.3: Instalar TypeScript](#sample-cdk-install-typescript).
1. Instale Node.js 16 ejecutando el comando ** `nvm` ** con la acción ** `install` **.
**nota**
También puede ejecutar **`nvm install node`**para instalar la versión de soporte a largo plazo (LTS) de Node.js. AWS Cloud9 el soporte rastrea la versión LTS de Node.js.
```
nvm install v16
```
1. Comience a utilizar Node.js 16. Para ello, ejecute el comando **`nvm`** junto con la acción **`alias`**, el número de versión para el alias y la versión que se va a utilizar para dicho alias, tal y como se indica a continuación.
```
nvm alias default 16
```
**nota**
El comando anterior establece Node.js 16 como la versión predeterminada de Node.js. Si lo desea, también puede ejecutar el comando **`nvm`** junto con la acción **`use`**, en lugar de la acción **`alias`** (por ejemplo, **`nvm use 16.17.0`**). Sin embargo, la acción **`use`** provoca que esa versión de Node.js solo se active mientras que la sesión del terminal actual se está ejecutando.
1. Para confirmar que está utilizando 16 Node.js, vuelva a ejecutar el comando ** `node --version` **. Si la versión instalada es la correcta, la salida incluirá la versión v16.
### Paso 1.3: Instalar TypeScript
1. Confirme si ya lo ha TypeScript instalado. Para ello, con la sesión de terminal aún abierta en el IDE, ejecute el TypeScript compilador de línea de comandos con la **`--version`**opción.
```
tsc --version
```
Si lo ha TypeScript instalado, el resultado contiene el número de TypeScript versión. Si TypeScript está instalado, pase a[Paso 1.4: Instale el AWS CDK](#sample-cdk-install-cdk).
1. Instalar TypeScript. Para ello, ejecute el **`npm`**comando con la **`install`**acción, la **`-g`**opción y el nombre del TypeScript paquete. Se instala TypeScript como un paquete global en el entorno.
```
npm install -g typescript
```
1. Confirme que TypeScript esté instalado. Para ello, ejecute el TypeScript compilador de línea de comandos con la **`--version`**opción.
```
tsc --version
```
Si TypeScript está instalado, la salida contiene el número de TypeScript versión.
### Paso 1.4: Instale el AWS CDK
1. Confirme si ya lo tiene AWS CDK instalado. Para ello, con la sesión del terminal aún abierta en el IDE, ejecute el comando ** `cdk` ** con la opción ** `--version` **.
```
cdk --version
```
Si AWS CDK está instalado, el resultado contiene los números de AWS CDK versión y compilación. Vaya a [Paso 2: Agregar el código](#sample-cdk-code).
1. Para instalarlo, ejecute el **`npm`**comando junto con la `install` acción, el nombre del AWS CDK paquete que se va a instalar y la `-g` opción de instalar el paquete globalmente en el entorno. AWS CDK
```
npm install -g aws-cdk
```
1. Confirme que AWS CDK está instalado y que está correctamente referenciado. Para ello, ejecute el comando **`cdk`** con la opción **`--version`**.
```
cdk --version
```
Si se ejecuta correctamente, se muestran los números de AWS CDK versión y compilación.
## Paso 2: Agregar el código
En este paso, se crea un TypeScript proyecto de ejemplo que contiene todo el código fuente que se necesita para implementar una AWS CloudFormation pila mediante programación. AWS CDK Esta pila crea un tema de Amazon SNS y una cola de Amazon SQS en AWS su cuenta y, a continuación, suscribe la cola al tema.
1. Con la sesión del terminal aún abierta en el IDE, cree un directorio para almacenar el código fuente del proyecto; por ejemplo, un directorio `~/environment/hello-cdk` en su entorno. Luego, cambie a ese directorio.
```
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 el directorio como un TypeScript proyecto de lenguaje para. AWS CDK Para ello, ejecute el comando **`cdk`** con la acción **`init`**, la plantilla **`sample-app`** y la opción **`--language`** junto con el nombre del lenguaje de programación.
```
cdk init sample-app --language typescript
```
De esta forma, se crean los siguientes archivos y subdirectorios en el directorio.
+ Un subdirectorio `.git` y un archivo`.gitignore` ocultos, que hacen que el proyecto sea compatible con herramientas de control de código fuente como Git.
+ Un subdirectorio `lib`, que incluye un archivo `hello-cdk-stack.ts`. Este archivo contiene el código de su AWS CDK pila. Este código se describe en el siguiente paso de este procedimiento.
+ Un subdirectorio `bin`, que incluye un archivo `hello-cdk.ts`. Este archivo contiene el punto de entrada de tu AWS CDK aplicación.
+ Un subdirectorio `node_modules`, que contiene los paquetes de código de apoyo que la aplicación y la pila pueden utilizar según sea necesario.
+ Un archivo `.npmignore` oculto, que enumera los tipos de subdirectorios y los archivos que **`npm`** no necesita al compilar el código.
+ Un archivo`cdk.json`, que contiene la información para poder ejecutar el comando **`cdk`** más fácilmente.
+ Un archivo `package-lock.json`, que contiene información que **`npm`** puede utilizar para reducir posibles errores de compilación y ejecución.
+ Un archivo `package.json`, que contiene información para poder ejecutar el comando **`npm`** más fácilmente y con posiblemente menos errores de compilación y ejecución.
+ Un `README.md` archivo en el que se enumeran los comandos útiles con los que puede ejecutar **`npm`**y los AWS CDK.
+ Un archivo `tsconfig.json`, que contiene información para poder ejecutar el comando **`tsc`** más fácilmente y con posiblemente menos errores de compilación y ejecución.
1. En la ventana **Environment** (Entorno), abra el archivo `lib/hello-cdk-stack.ts` y examine el siguiente código en ese archivo.
```
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);
}
}
```
+ `Topic`Las clases `Stack``App`,`StackProps`,`Queue`, y representan una CloudFormation pila y sus propiedades, un programa ejecutable, una cola de Amazon SQS y un tema de Amazon SNS, respectivamente.
+ La `HelloCdkStack` clase representa la CloudFormation pila de esta aplicación. Esta pila contiene la nueva cola de Amazon SQS y el tema de Amazon SNS para esta aplicación.
1. En la ventana **Environment** (Entorno), abra el archivo `bin/hello-cdk.ts` y examine el siguiente código en ese archivo.
```
#!/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();
```
Este código carga, crea una instancia y luego ejecuta la clase `HelloCdkStack` a partir del archivo `lib/hello-cdk-stack.ts`.
1. Se utiliza **`npm`**para ejecutar el TypeScript compilador para comprobar si hay errores de codificación y, AWS CDK a continuación, habilitar la ejecución del `bin/hello-cdk.js` archivo del proyecto. Para ello, desde el directorio raíz del proyecto, ejecute el comando **`npm`** con la acción **`run`** y especifique el valor del comando **`build`** en el archivo `package.json`, tal y como se indica a continuación.
```
npm run build
```
El comando anterior ejecuta el TypeScript compilador, que añade archivos `bin/hello-cdk.d.ts` y `lib/hello-cdk-stack.d.ts` soportes. El compilador también transpone los archivos `hello-cdk-stack.ts` y `hello-cdk.ts` en los archivos `hello-cdk-stack.js` y `hello-cdk.js`.
## Paso 3: Ejecutar el código
En este paso, le indicas AWS CDK que creen una plantilla de CloudFormation pila basada en el código del archivo. `bin/hello-cdk.js` A continuación, le indicas que AWS CDK desplieguen la pila, lo que crea el tema de Amazon SNS y la cola de Amazon SQS y, a continuación, suscribe la cola al tema. Luego, confirme que el tema y la cola se han implementado correctamente enviando un mensaje del tema a la cola.
1. Haga que creen la plantilla de pila. AWS CDK CloudFormation Para ello, con la sesión del terminal aún abierta en el IDE, desde el directorio raíz del proyecto, ejecute el comando ** `cdk` ** con la acción ** `synth` ** y el nombre de la pila.
```
cdk synth HelloCdkStack
```
Si tiene éxito, el resultado muestra la `Resources` sección de la plantilla de CloudFormation pila.
1. La primera vez que despliegues una AWS CDK aplicación en un entorno para una combinación específica de AWS cuenta y AWS región, debes instalar una *pila de arranque.* Esta pila incluye varios recursos que AWS CDK necesita para completar sus distintas operaciones. Por ejemplo, esta pila incluye un bucket de Amazon S3 que AWS CDK utiliza para almacenar plantillas y activos durante sus procesos de implementación. Para instalar la pila de arranque, ejecute el comando ** `cdk` ** con la acción ** `bootstrap` **.
```
cdk bootstrap
```
**nota**
Si se ejecuta `cdk bootstrap` sin especificar ninguna opción, se utilizan la AWS cuenta y AWS la región predeterminadas. También puede iniciar un entorno específico especificando un perfil y una account/Region combinación. Por ejemplo:
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. Haga que AWS CDK ejecuten la plantilla de CloudFormation pila para implementar la pila. Para ello, desde el directorio raíz del proyecto, ejecute el comando **`cdk`** con la acción **`deploy`** y el nombre de la pila.
```
cdk deploy HelloCdkStack
```
Si se ejecuta correctamente, la salida muestra que la pila `HelloCdkStack` se ha implementado sin errores.
**nota**
Si el resultado muestra un mensaje en el que se indica que la pila no define un entorno y que AWS las credenciales no se pudieron obtener de ubicaciones estándar o que no se configuró ninguna región, asegúrese de que AWS las credenciales estén configuradas correctamente en el IDE y, a continuación, ejecute el **`cdk deploy`**comando de nuevo. Para obtener más información, consulte [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md).
1. Para confirmar que el tema de Amazon SNS y la cola de Amazon SQS se han implementado correctamente, envíe un mensaje al tema y, luego, verifique la cola para ver si se ha recibido el mensaje. Para ello, puede utilizar una herramienta como el AWS Command Line Interface (AWS CLI) o el AWS CloudShell. Para obtener más información sobre estas herramientas, consulte [AWS CLI y tutorial de aws-shell para AWS Cloud9](sample-aws-cli.md).
Por ejemplo, para enviar un mensaje al tema, con la sesión de terminal aún abierta en el IDE, utilice el **`publish`**comando AWS CLI to run Amazon SNS, proporcionando el asunto y el cuerpo del mensaje, la AWS región del tema y el nombre de recurso de Amazon (ARN) del tema.
```
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
```
En el comando anterior, `arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K` sustitúyalo por el ARN que se CloudFormation asigna al tema. Para obtener el ID, puede ejecutar el comando ** `list-topics` ** de Amazon SNS.
```
aws sns list-topics --output table --query 'Topics[*].TopicArn'
```
Si se ejecuta correctamente, la salida del comando ** `publish` ** muestra el valor de `MessageId` del mensaje que se publicó.
Para verificar la cola para ver si se ha recibido el mensaje, ejecute el comando ** `receive-message` ** de Amazon SQS y proporcione la URL de la cola.
```
aws sqs receive-message --queue-url https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K
```
En el comando anterior, `https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K` sustitúyalo por el ARN que se CloudFormation asigna a la cola. Para obtener la URL, puede ejecutar el comando ** `list-queues` ** de Amazon SQS.
```
aws sqs list-queues --output table --query 'QueueUrls[*]'
```
Si se ejecuta correctamente, la salida del comando **`receive-message`** muestra información del mensaje que se recibió.
## Paso 4: Limpiar
Para evitar que se hagan cargos continuos a tu AWS cuenta una vez que hayas terminado de usar este ejemplo, debes eliminar la pila. CloudFormation De esta forma se eliminan el tema de Amazon SNS y la cola de Amazon SQS. También debe eliminar el entorno.
### Paso 4.1: Eliminar la pila
Con la sesión del terminal aún abierta en el IDE, desde el directorio raíz del proyecto, ejecute el comando ** `cdk` ** con la acción ** `destroy` ** y el nombre de la pila.
```
cdk destroy HelloCdkStack
```
Cuando se le pida que elimine la pila, escriba `y` y, a continuación, pulse `Enter`.
Si se ejecuta correctamente, la salida muestra que la pila `HelloCdkStack` se ha eliminado sin errores.
### Paso 4.2: Eliminar el entorno
Para eliminar el entorno, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# Tutorial de LAMP para AWS Cloud9
Este tutorial le permite configurar y ejecutar LAMP (Linux, Apache Servidor HTTP, MySQL, y PHP) dentro de un entorno AWS Cloud9 de desarrollo.
Seguir este tutorial y crear este ejemplo puede resultar en gastos para usted Cuenta de AWS. Estos incluyen posibles cargos por Servicios de AWS ejemplo Amazon Elastic Compute Cloud (Amazon EC2). Para obtener más información, consulta los [ EC2 precios de Amazon](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Requisitos previos](#sample-lamp-prereqs)
+ [Paso 1: Instalar las herramientas](#sample-lamp-install-tools)
+ [Paso 2: Configurar MySQL](#sample-lamp-setup-mysql)
+ [Paso 3: Configurar un sitio web](#sample-lamp-apache)
+ [Paso 4: Limpiar](#sample-lamp-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de AWS Cloud9 EC2 desarrollo existente.** En este ejemplo se supone que ya tienes un EC2 entorno conectado a una EC2 instancia de Amazon que ejecuta Amazon Linux o Ubuntu Servidor. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar las herramientas
En este paso, instalará las siguientes herramientas:
+ Apache Servidor HTTP, un host de servidor web.
+ PHP, un lenguaje de script especialmente indicado para el desarrollo web y que se puede incrustar en HTML.
+ MySQL, un sistema de administración de bases de datos.
A continuación, finalice este paso iniciando Apache Servidor HTTP y, a continuación MySQL.
1. Asegúrese de que las últimas actualizaciones de seguridad y correcciones de errores están instaladas en la instancia. Para ello, en una sesión de terminal en el AWS Cloud9 IDE, ejecute **`yum update`**for (Amazon Linux) o **`apt update`**for (Ubuntu Servidor). (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**).
Para Amazon Linux:
```
sudo yum -y update
```
En Ubuntu Servidor:
```
sudo apt -y update
```
1. Compruebe si Apache El servidor HTTP ya está instalado. Para ello, ejecute **`httpd -v`**(para Amazon Linux) o **`apache2 -v`**(para Ubuntu El comando (servidor).
Si se ejecuta correctamente, el resultado contiene el Apache Número de versión del servidor HTTP.
Si ve un error, instale Apache Servidor HTTP ejecutando el **`install`**comando.
Para Amazon Linux:
```
sudo yum install -y httpd24
```
En Ubuntu Servidor:
```
sudo apt install -y apache2
```
1. Confirme si PHP ya está instalado ejecutando el **`php -v`**comando.
Si es así, el resultado contendrá el número de versión de PHP.
Si aparece un error, instale PHP ejecutando el comando **`install`**.
Para Amazon Linux:
```
sudo yum install -y php56
```
En Ubuntu Servidor:
```
sudo apt install -y php libapache2-mod-php php-xml
```
1. Confirme si MySQL ya está instalado ejecutando el **`mysql --version`**comando.
Si se ejecuta correctamente, el resultado contiene el MySQL número de versión.
Si ve un error, instale MySQL ejecutando el **`install`**comando.
Para Amazon Linux:
```
sudo yum install -y mysql-server
```
En Ubuntu Servidor:
```
sudo apt install -y mysql-server
```
1. Después de instalar Apache Servidor HTTP, PHP, y MySQL, iniciar Apache Servidor HTTP y, a continuación, confirme que se ha iniciado ejecutando el siguiente comando.
Para Amazon Linux (es posible que tenga que ejecutar el comando dos veces):
```
sudo service httpd start && sudo service httpd status
```
En Ubuntu Servidor (para volver a la línea de comandos, presione`q`):
```
sudo service apache2 start && sudo service apache2 status
```
1. Inicio MySQLy, a continuación, confirme que se ha iniciado ejecutando el siguiente comando.
Para Amazon Linux:
```
sudo service mysqld start && sudo service mysqld status
```
En Ubuntu Servidor (para volver a la línea de comandos, presione`q`):
```
sudo service mysql start && sudo service mysql status
```
## Paso 2: Configurar MySQL
En este paso, configuras MySQL para seguir MySQL mejores prácticas de seguridad. Estas prácticas recomendadas de seguridad incluyen establecer una contraseña para las cuentas raíz y eliminar las cuentas raíz a las que se puede acceder desde fuera del host local. Otras prácticas recomendadas a tener en cuenta son eliminar los usuarios anónimos, eliminar la base de datos de prueba y eliminar los privilegios que permiten a cualquier persona acceder a las bases de datos con nombres que comiencen por `test_`.
A continuación, finalice este paso practicando el inicio y, a continuación, la salida del MySQL cliente de línea de comandos.
1. Implementar MySQL mejores prácticas de seguridad para el MySQL instalación mediante la ejecución del siguiente comando en una sesión de terminal en el AWS Cloud9 IDE.
```
sudo mysql_secure_installation
```
1. Cuando se le solicite, responda a las siguientes preguntas.
Para Amazon Linux:
1. **Enter current password for root (enter for none)** (Ingrese la contraseña raíz actual [Intro para ninguna]: pulse `Enter` (sin contraseña).
1. **Set root password** (Establecer la contraseña raíz): escriba `Y` y, a continuación, pulse `Enter`.
1. **New password** (Nueva contraseña): escriba una contraseña y, a continuación, pulse `Enter`.
1. **Re-enter new password** (Volver a ingresar la nueva contraseña): escriba la contraseña de nuevo y, a continuación, pulse `Enter`. (Asegúrese de almacenar la contraseña en un lugar seguro para usarla más adelante).
1. **Remove anonymous users** (Eliminar usuarios anónimos): escriba `Y` y, a continuación, pulse `Enter`.
1. **Disallow root login remotely** (No permitir el inicio de sesión raíz de forma remota): escriba `Y` y, a continuación, pulse `Enter`.
1. **Remove test database and access to it** (Eliminar la base de datos de prueba y acceder a ella): escriba `Y` y, a continuación, pulse `Enter`.
1. **Reload privilege tables now** (Volver a cargar tablas de privilegios ahora): escriba `Y` y, a continuación, pulse `Enter`.
En Ubuntu Servidor:
1. **Would you like to set up VALIDATE PASSWORD plugin** (¿Quiere configurar el complemento VALIDATE PASSWORD?): escriba `y` y, a continuación, pulse `Enter`.
1. **There are three levels of password validation policy** (Existen tres niveles de política de validación de contraseñas): escriba `0`, `1`, o `2` y, a continuación, pulse `Enter`.
1. **New password** (Nueva contraseña): escriba una contraseña y, a continuación, pulse `Enter`.
1. **Re-enter new password** (Volver a introducir la nueva contraseña): escriba la contraseña de nuevo y, a continuación, pulse `Enter`. Asegúrese de guardar la contraseña en un lugar seguro para usarla más adelante.
1. **Do you wish to continue with the password provided** (¿Desea continuar con la contraseña proporcionada?): escriba `y` y, a continuación, pulse `Enter`.
1. **Remove anonymous users** (Eliminar usuarios anónimos): escriba `y` y, a continuación, pulse `Enter`.
1. **Disallow root login remotely** (No permitir el inicio de sesión raíz de forma remota): escriba `y` y, a continuación, pulse `Enter`.
1. **Remove test database and access to it** (Eliminar la base de datos de prueba y acceder a ella): escriba `y` y, a continuación, pulse `Enter`.
1. **Reload privilege tables now** (Volver a cargar tablas de privilegios ahora): escriba `y` y, a continuación, pulse `Enter`.
1. Para interactuar directamente con MySQL, inicie el MySQL cliente de línea de comandos como usuario root ejecutando el siguiente comando. Cuando se le solicite, escriba la contraseña del usuario raíz que ha definido anteriormente y, a continuación, pulse `Enter`. El mensaje cambia a `mysql>` cuando se encuentra en el MySQL cliente de línea de comandos.
```
sudo mysql -uroot -p
```
1. Para salir del MySQL cliente de línea de comandos, ejecute el siguiente comando. El símbolo vuelve a cambiar a `$`.
```
exit;
```
## Paso 3: Configurar un sitio web
En este paso, configurará la raíz del sitio web predeterminada para Apache Servidor HTTP con propietarios y permisos de acceso recomendados. A continuación, crea un PHPpágina web basada en la raíz de ese sitio web predeterminado.
A continuación, habilita el tráfico web entrante para ver esa página web configurando el grupo de seguridad en Amazon EC2 y la lista de control de acceso a la red (ACL de red) en Amazon Virtual Private Cloud (Amazon VPC) que están asociados a este EC2 entorno. Cada EC2 entorno debe estar asociado a un grupo de seguridad en Amazon EC2 y a una ACL de red en Amazon VPC. Sin embargo, aunque la ACL de red predeterminada de una Cuenta de AWS permite todo el tráfico de entrada y salida del entorno, el grupo de seguridad predeterminado permite únicamente el tráfico entrante mediante SSH a través del puerto 22. Para obtener más información, consulte [Configuración de VPC para entornos de desarrollo AWS Cloud9](vpc-settings.md).
Para finalizar este paso, debe ver correctamente la página web desde fuera del IDE de AWS Cloud9 .
1. Configure la raíz del sitio web predeterminada para Apache Servidor HTTP (`/var/www/html`) con propietarios y permisos de acceso recomendados. Para ello, ejecute los seis comandos siguientes, uno a la vez y en el orden siguiente, en una sesión de terminal en el AWS Cloud9 IDE. Para entender lo que hace cada comando, lea la información que aparece detrás del comando `#` en 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.
```
En 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. Cree un PHPpágina web basada `index.php` en el nombre de la carpeta raíz del sitio web predeterminado para Apache Servidor HTTP (que es`/var/www/html`) ejecutando el siguiente 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
```
El comando anterior para Amazon Linux también cambia el propietario del archivo a`ec2-user`, cambia el grupo del archivo a `web-content` y cambia los permisos del archivo a read/write for the user, and read/execute para el grupo y otros.
En 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
```
El comando anterior para Ubuntu El servidor también cambia el propietario del archivo a`ubuntu`, cambia el grupo del archivo a `web-content` y cambia los permisos del archivo read/write for the user, and read/execute para el grupo y otros usuarios.
Si se ejecuta correctamente, los comandos anteriores crean el archivo `index.php` con el siguiente contenido.
```
```
1. Habilite el tráfico web entrante a través del puerto 80 para ver la nueva página web configurando la ACL de red en Amazon VPC y el grupo de seguridad Amazon EC2 asociado a este EC2 entorno. Para ello, ejecute los ocho comandos siguientes, de uno en uno, en el orden que se indica a continuación. Para entender lo que hace cada comando, lea la información que aparece detrás del comando `#` en cada comando.
**importante**
La ejecución de los siguientes comandos habilita el tráfico web entrante a través del puerto 80 para **todos los** EC2 entornos e EC2 instancias de Amazon que estén asociados al grupo de seguridad y a la ACL de red de este entorno. Esto podría provocar que se habilite inesperadamente el tráfico web entrante a través del puerto 80 para EC2 entornos e EC2 instancias de Amazon distintos de este.
**nota**
Los comandos del segundo al cuarto siguientes habilitan el grupo de seguridad para permitir el tráfico web entrante a través del puerto 80. Si tiene un grupo de seguridad predeterminado, que solo permite el tráfico SSH a través del puerto 22, debe ejecutar el primer comando y después los comandos del segundo al cuarto. Sin embargo, si tiene un grupo de seguridad personalizado que ya permite el tráfico web entrante a través del puerto 80, puede omitir la ejecución de estos comandos.
Los comandos del quinto al octavo siguientes habilitan la ACL de red para permitir el tráfico web entrante a través del puerto 80. Si tiene una ACL de red predeterminada, que ya permite todo el tráfico entrante a través de todos los puertos, puede pasar por alto la ejecución de dichos comandos. Sin embargo, supongamos que tiene una ACL de red personalizada que no habilita el tráfico web entrante a través del puerto 80. A continuación, ejecute el primer comando seguido de los comandos quinto a octavo.
```
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. Obtenga la URL al archivo `index.php` en la raíz del servidor web. Para ello, ejecute el siguiente comando y utilice una nueva pestaña del navegador web o un navegador web distinto del AWS Cloud9 IDE para ir a la URL que se muestra. Si se ejecuta correctamente, la página web muestra información sobre Apache Servidor HTTP, MySQL, PHP, y otros ajustes relacionados.
```
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.
```
## Paso 4: Limpiar
Supongamos que desea seguir utilizando este entorno, pero desea deshabilitar el tráfico web entrante a través del puerto 80. En ese caso, ejecute los ocho comandos siguientes, uno por uno, en el orden que se indica a continuación, para eliminar las reglas de tráfico entrante correspondientes que configuró anteriormente en el grupo de seguridad y en la ACL de red que están asociados al entorno. Para entender lo que hace cada comando, lea la información que aparece detrás del comando `#` en cada comando.
**importante**
La ejecución de los siguientes comandos deshabilita el tráfico web entrante a través del puerto 80 en **todos los** EC2 entornos e EC2 instancias de Amazon que estén asociados al grupo de seguridad y a la ACL de red de este entorno. Esto podría provocar la desactivación inesperada del tráfico web entrante a través del puerto 80 para EC2 entornos e EC2 instancias de Amazon distintos de este.
**nota**
Los comandos del quinto al octavo siguientes eliminan las reglas existentes para impedir que la ACL de red permita el tráfico web entrante a través del puerto 80. Si tiene una ACL de red predeterminada, que ya permite todo el tráfico entrante a través de todos los puertos, puede omitir la ejecución de dichos comandos. Sin embargo, supongamos que tiene una ACL de red personalizada con reglas existentes que permiten el tráfico web entrante a través del puerto 80 y desea eliminar esas reglas. En ese caso, ejecute el primer comando seguido de los comandos quinto a octavo.
```
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.
```
Si ha terminado de usar este entorno, elimínelo para evitar que se apliquen cargos continuos en su Cuenta de AWS. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# WordPress tutorial para AWS Cloud9
Este tutorial le permite instalar y ejecutar WordPress en un entorno de AWS Cloud9 desarrollo. WordPress es un sistema de administración de contenido (CMS) de código abierto que se usa ampliamente para la entrega de contenido web.
**nota**
Si sigue este tutorial y crea este ejemplo, es posible que se le cobren cargos a su AWS cuenta. Entre estos se incluyen posibles cargos por servicios como Amazon Elastic Compute Cloud (Amazon EC2). Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/).
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
+ **Tiene una instancia up-to-date EC2 con todos los paquetes de software más recientes**. En la ventana del terminal AWS Cloud9 IDE, tiene `yum update` la `-y` opción de instalar actualizaciones sin pedir confirmación. Si le gustaría examinar las actualizaciones antes de la instalación, puede omitir esta opción.
```
sudo yum update -y
```
## Información general de la instalación
La instalación WordPress en la instancia EC2 de su entorno implica los siguientes pasos:
1. Instalación y configuración del servidor MariaDB, que es una base de datos relacional de código abierto que almacena información para las instalaciones WordPress
1. Instalación y configuración WordPress, lo que incluye la edición del archivo de configuración `wordpress.conf`
1. Configurar el servidor Apache que aloja el WordPress sitio
1. Vista previa del contenido WordPress web alojado en el servidor Apache
## Paso 1: Instalación y configuración del servidor MariaDB
1. En el AWS Cloud9 IDE, seleccione **Ventana**, **Nueva terminal** e introduzca los siguientes comandos para instalar e iniciar una instalación del servidor MariaDB:
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. A continuación, ejecute el script de `mysql_secure_installation` para mejorar la seguridad de la instalación del servidor MariaDB.
Cuando proporcione respuestas al script, presione **Intro** en la primera pregunta para mantener la contraseña raíz en blanco. Pulse **n** para `Set root password?` y, luego, **y** para cada una de las demás opciones de seguridad.
```
mysql_secure_installation
```
1. Ahora cree una tabla de base de datos para almacenar WordPress información con el cliente MariaDB.
(Pulse **Intro** cuando se le solicite la contraseña).
```
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 cerrar la sesión en el cliente MariaDB, ejecute el comando `exit`.
## Paso 2: Instalación y configuración WordPress
1. En la ventana del terminal del IDE, diríjase al directorio `environment` y, a continuación, cree los directorios `config` y `wordpress`. A continuación, ejecute el comando `touch` para crear un archivo denominado `wordpress.conf` en el directorio `config`:
```
cd /home/ec2-user/environment
mkdir config wordpress
touch config/wordpress.conf
```
1. Utilice el editor IDE o vim para actualizar `wordpress.conf` con la información de configuración del host que permite al servidor Apache servir WordPress contenido:
```
# Ensure that Apache listens on port 80
Listen 8080
DocumentRoot "/var/www/wordpress"
ServerName www.example.org
# Other directives here
```
1. Ahora ejecute los siguientes comandos para recuperar el archivo comprimido necesario e instalarlo WordPress:
```
cd /home/ec2-user/environment
wget https://wordpress.org/latest.tar.gz
tar xvf latest.tar.gz
```
1. Ejecute el comando `touch` para crear un archivo denominado `wp-config.php` en el directorio `environment/wordpress`:
```
touch wordpress/wp-config.php
```
1. Utilice el editor IDE o vim para actualizar `wp-config.php` y reemplace los datos de muestra con su configuración:
```
// ** 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';
```
## Paso 3: Configurar el servidor HTTP Apache
1. En la ventana del terminal AWS Cloud9 IDE, asegúrese de tener instalado Apache:
```
httpd -v
```
Para instalar el servidor HTTP de Apache, ejecute el siguiente comando:
```
sudo yum install -y httpd
```
1. Vaya al directorio `/etc/httpd/conf.d`, que es la ubicación de los archivos de configuración del anfitrión virtual de Apache. A continuación, utilice el comando `ln` para vincular el archivo `wordpress.conf` que creó anteriormente al directorio de trabajo actual (`/etc/httpd/conf.d`):
```
cd /etc/httpd/conf.d
sudo ln -s /home/ec2-user/environment/config/wordpress.conf
```
1. Ahora diríjase al directorio `/var/www`, que es la carpeta raíz predeterminada para los servidores Apache. A continuación, utilice el comando `ln` para vincular el directorio `wordpress` que creó anteriormente al directorio de trabajo actual (`/var/www`):
```
cd /var/www
sudo ln -s /home/ec2-user/environment/wordpress
```
1. Ejecute el comando `chmod` para permitir que el servidor Apache ejecute contenido en el subdirectorio `wordpress`:
```
sudo chmod +x /home/ec2-user/
```
1. Ahora reinicie el servidor Apache para permitirle detectar las nuevas configuraciones:
```
sudo service httpd restart
```
## Paso 4: previsualizar el contenido WordPress web
1. Usando el AWS Cloud9 IDE, cree un nuevo archivo llamado `index.html` en el siguiente directorio:`environment/wordpress`.
1. Agregue texto con formato HTML al archivo `index.html`. Por ejemplo:
```
Hello World!
```
1. En la ventana **Entorno**, elija el archivo `index.html` y, a continuación, elija **Vista previa**, **Vista previa de aplicación en ejecución**.
La página web, que muestra el mensaje *¡Hola, mundo\$1*, aparece en la pestaña de vista previa de la aplicación. Para ver el contenido web en su navegador preferido, elija **Pop Out Into a New Window** (Mostrar en una ventana nueva).
Si elimina el `index.html` archivo y actualiza la pestaña de vista previa de la aplicación, se muestra la página de WordPress configuración.
## Administración de errores de contenido mixto
Los navegadores web muestran errores de contenido mixto para un WordPress sitio si carga contenido o scripts HTTPS y HTTP al mismo tiempo. La redacción de los mensajes de error depende del navegador web que esté utilizando, pero se le informa de que su conexión a un sitio es insegura o no totalmente segura. Asimismo, el navegador web bloquea el acceso al contenido mixto.
**importante**
De forma predeterminada, todas las páginas web a las que accede en la pestaña de vista previa de la aplicación del IDE de AWS Cloud9 utilizan automáticamente el protocolo HTTPS. Si el URI de una página presenta el protocolo no seguro `http`, se reemplaza automáticamente por `https`. Para acceder al contenido no seguro, tampoco puede restablecer `https` a `http` manualmente.
Para obtener orientación sobre cómo implementar HTTPS en su sitio web, consulte la [WordPressdocumentación](https://wordpress.org/support/article/https-for-wordpress/).
# Tutorial de Java para AWS Cloud9
**importante**
Si utiliza un entorno de AWS Cloud9 desarrollo respaldado por una instancia EC2 con 2 GiB o más de memoria, le recomendamos que active la compatibilidad mejorada con Java. Esto proporciona acceso a características de productividad clave como la finalización de código, lint de errores, acciones específicas del contexto y opciones de depuración, como puntos de interrupción e incrementos.
Para obtener más información, consulte [Compatibilidad con el desarrollo de Java mejorada](enhanced-java.md).
Este tutorial le permite ejecutar parte del código Java en un entorno de AWS Cloud9 desarrollo.
El uso de este tutorial y la creación de esta muestra pueden generar cargos en su cuenta de AWS . Entre estos se incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-java-prerequisites)
+ [Paso 1: Instalar las herramientas necesarias](#sample-java-install)
+ [Paso 2: Agregar el código](#sample-java-code)
+ [Paso 3: Compilar y ejecutar el código](#sample-java-run)
+ [Paso 4: Configúrelo para usar el AWS SDK para Java](#sample-java-sdk)
+ [Paso 5: Configure la administración de AWS credenciales en su entorno](#sample-java-sdk-creds)
+ [Paso 6: Agrega el código AWS del SDK](#sample-java-sdk-code)
+ [Paso 7: Compila y ejecuta el código del AWS SDK](#sample-java-sdk-run)
+ [Paso 8: Eliminación](#sample-java-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar las herramientas necesarias
En este paso, instalará un conjunto de herramientas de desarrollo de Java en su entorno de AWS Cloud9 desarrollo. Si ya tiene un conjunto de herramientas de desarrollo de Java como Oracle JDK u OpenJDK instalado en su entorno, continúe en [Paso 2: Agregar el código](#sample-java-code). Esta muestra se desarrolló con OpenJDK 8, que puede instalar en su entorno realizando el siguiente procedimiento.
1. Confirme si OpenJDK 8 ya está instalado. Para ello, en una sesión de terminal en el AWS Cloud9 IDE, ejecute la versión de línea de comandos del ejecutor de Java con la **`-version`**opción. (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**).
```
java -version
```
En función del resultado del comando anterior, realice una de las siguientes acciones:
+ Si el resultado indica que no se encuentra el comando `java`, continúe con el paso 2 de este procedimiento para instalar OpenJDK 8.
+ Si el resultado contiene valores que comienzan con `Java(TM)`, `Java Runtime Environment`, `Java SE`, `J2SE` o `Java2`, el OpenJDK no está instalado o no se ha establecido como el conjunto de herramientas de desarrollo de Java predeterminado. Continúe con el paso 2 de este procedimiento para instalar OpenJDK 8 y, a continuación, cambie a OpenJDK 8.
+ Si el resultado contiene valores que comienzan por `java version 1.8` y `OpenJDK`, continúe en [Paso 2: Agregar el código](#sample-java-code). OpenJDK 8 se instala correctamente para esta muestra.
+ Si el resultado contiene un `java version` menor que `1.8` y valores que comienzan por `OpenJDK`, continúe con el paso 2 de este procedimiento para actualizar la versión de OpenJDK instalada a OpenJDK 8.
1. Asegúrese de que las últimas actualizaciones de seguridad y correcciones de errores están instaladas. Para ello, ejecute la herramienta yum (para Amazon Linux) o la herramienta apt (para Ubuntu Server) con el comando ** `update` **.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Instale OpenJDK 8. Para ello, ejecute la herramienta yum (para Amazon Linux) o la herramienta apt (para Ubuntu Server) con el comando ** `install` ** y especifique el paquete 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 obtener más información, consulte [Cómo descargar e instalar paquetes OpenJDK preconfigurados](https://openjdk.org/install/) en el sitio web de OpenJDK.
1. Cambie o actualice el conjunto de herramientas de desarrollo Java predeterminado a OpenJDK 8. Para ello, ejecute el comando **`update-alternatives`** con la opción **`--config`**. Ejecute este comando dos veces para cambiar o actualizar las versiones de la línea de comandos del ejecutor y compilador de Java.
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
En cada solicitud, escriba el número de selección para OpenJDK 8 (el que contiene `java-1.8`).
1. Confirme que las versiones de la línea de comandos del ejecutor y el compilador de Java utilizan OpenJDK 8. Para ello, ejecute las versiones de la línea de comandos del ejecutor y el compilador de Java con la opción `-version`.
```
java -version
javac -version
```
Si OpenJDK 8 está instalado y configurado correctamente, la salida de la versión del ejecutador de Java contiene un valor que comienza por `openjdk version 1.8` y la salida de la versión del compilador de Java comienza por el valor `javac 1.8`.
## Paso 2: Agregar el código
En el AWS Cloud9 IDE, cree un archivo con el siguiente código y guárdelo con ese nombre`hello.java`. (Para crear un archivo, en la barra de menús, elija **File** [Archivo], **New File** [Archivo nuevo]. Para guardar el archivo, elija **File** [Archivo], **Save** [Guardar]).
```
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));
}
}
```
## Paso 3: Compilar y ejecutar el código
1. Utilice la versión de la línea de comandos del compilador de Java para compilar el archivo `hello.java` en un archivo `hello.class`. Para ello, utilizando el terminal del AWS Cloud9 IDE, desde el mismo directorio que el `hello.java` archivo, ejecute el compilador de Java, especificando el `hello.java` archivo.
```
javac hello.java
```
1. Utilice la versión de la línea de comandos del ejecutador de Java para ejecutar el archivo `hello.class`. Para ello, desde el mismo directorio que el archivo `hello.class`, ejecute el ejecutador de Java, especificando el nombre de la clase `hello` que se declaró en el archivo `hello.java`, con dos enteros para añadirlos (por ejemplo, `5` y `9`).
```
java hello 5 9
```
1. Compare sus resultados.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Paso 4: Configúrelo para usar el AWS SDK para Java
Puede mejorar este ejemplo para usarlo AWS SDK para Java para crear un bucket de Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket que acaba de crear.
En este paso, instale [Apache Maven](https://maven.apache.org/) o [Gradle](https://gradle.org/) en su entorno. Maven y Gradle son sistemas de automatización de compilación comunes que se pueden utilizar con proyectos Java. Después de instalar Maven o Gradle, se usa para generarlo un nuevo proyecto Java. En este nuevo proyecto, añada una referencia al AWS SDK para Java. Esto AWS SDK para Java proporciona una forma cómoda de interactuar con AWS servicios como Amazon S3, desde su código Java.
**Topics**
+ [Configuración con Maven](#sample-java-sdk-maven)
+ [Configuración con Gradle](#sample-java-sdk-gradle)
### Configuración con Maven
1. Instale Maven en su entorno. Para comprobar si Maven ya está instalado, utilice el terminal del AWS Cloud9 IDE para ejecutar Maven con la **`-version`**opción.
```
mvn -version
```
Si es así, el resultado contendrá el número de versión de Maven. Si Maven ya está instalado, vaya al paso 4 de este procedimiento para utilizar Maven con el fin de generar un nuevo proyecto Java en su entorno.
1. Instale Maven utilizando el terminal para ejecutar los siguientes comandos.
Para Amazon Linux, los siguientes comandos obtienen información sobre el repositorio de paquetes donde se almacena Maven y, a continuación, utilizan esta información para instalar 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 obtener más información sobre los comandos anteriores, consulte [Paquetes Extra para Enterprise Linux (EPEL)](https://docs.fedoraproject.org/en-US/epel/) en el sitio web wiki del proyecto Fedora.
Para Ubuntu Server, ejecute en cambio el siguiente comando.
```
sudo apt install -y maven
```
1. Confirme la instalación ejecutando Maven con la opción ** `-version` **.
```
mvn -version
```
1. Utilice Maven para generar un nuevo proyecto Java. Para ello, utilice el terminal para ejecutar el siguiente comando desde el directorio donde desea que Maven genere el proyecto (por ejemplo, el directorio raíz de su entorno).
```
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
El comando anterior crea la siguiente estructura de directorios para el proyecto en su entorno.
```
my-app
|- src
| `- main
| `- java
| `- com
| `- mycompany
| `- app
| `-App.java
|- test
| `- java
| `- com
| `- mycompany
| `- app
| `- AppTest.java
`- pom.xml
```
Para obtener más información sobre la estructura de directorios anterior, consulte [Arquetipo de inicio rápido de Maven](https://maven.apache.org/archetypes/maven-archetype-quickstart/) e [Introducción al diseño de directorios estándar](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) en el sitio web del proyecto Apache Maven.
1. Modifique el archivo Project Object Model (POM) del proyecto. (Un archivo POM define la configuración de un proyecto Maven). Para ello, en la ventana **Environment (Entorno)**, abra el archivo `my-app/pom.xml`. En el editor, reemplace el contenido actual del archivo por el siguiente código y, a continuación, guarde el archivo `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
```
El archivo POM anterior incluye la configuración del proyecto que especifica declaraciones como las siguientes:
+ La configuración `artifactid` de `my-app` establece el nombre del directorio raíz del proyecto y la configuración `group-id` de `com.mycompany.app` establece la estructura de subdirectorios `com/mycompany/app` y la declaración `package` en los archivos `App.Java` y `AppTest.java`.
+ La configuración `artifactId` de `my-app`, con la configuración `packaging` de `jar`, la configuración `version` de `1.0-SNAPSHOT` y la configuración `descriptorRef` de `jar-with-dependencies` establece el nombre del archivo JAR de salida de `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar`.
+ La sección `plugin` declara que se creará un único JAR, que incluye todas las dependencias.
+ La `dependency` sección con la `groupId` configuración de `com.amazon.aws` y la configuración de `aws-java-sdk` incluye los `artifactId` archivos de la AWS SDK para Java biblioteca. La versión de AWS SDK para Java que se usará se declara mediante la configuración `version`. Para utilizar otra versión, reemplace este número de versión.
Vaya a [Paso 5: Configure la administración de AWS credenciales en su entorno](#sample-java-sdk-creds).
### Configuración con Gradle
1. Instale Gradle en su entorno. Para comprobar si Gradle ya está instalado, usa el terminal del AWS Cloud9 IDE y ejecuta Gradle con la **`-version`**opción.
```
gradle -version
```
Si es así, el resultado contendrá el número de versión de Gradle. Si Gradle ya está instalado, vaya al paso 4 de este procedimiento para utilizar Gradle con el fin de generar un nuevo proyecto Java en su entorno.
1. Instale Gradle utilizando el terminal para ejecutar los siguientes comandos. Estos comandos instalan y ejecutan la herramienta SDKMAN\$1 y, a continuación, utilizan SDKMAN\$1 para instalar la última versión de Gradle.
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
Para obtener más información sobre los comandos anteriores, consulte [Installation](https://sdkman.io/install) en el sitio web de SDKMAN e [Install with a package manager](https://gradle.org/install/#with-a-package-manager) en el sitio web Gradle.
1. Confirme la instalación ejecutando Gradle con la opción ** `-version` **.
```
gradle -version
```
1. Utilice Gradle para generar un nuevo proyecto Java en su entorno. Para ello, use el terminal para ejecutar los siguientes comandos con el fin de crear un directorio para el proyecto y, a continuación, cambie a ese directorio.
```
mkdir my-app
cd my-app
```
1. Ejecute el siguiente comando para que Gradle genere un nuevo proyecto de aplicación Java en el directorio `my-app` de su entorno.
```
gradle init --type java-application
```
El comando anterior crea la siguiente estructura de directorios para el proyecto en su entorno.
```
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 `AppTest.java` para el proyecto. (Si no lo hace, es posible que el proyecto no se compile ni ejecute del modo previsto). Para ello, en la ventana **Environment (Entorno)**, abra el archivo `my-app/src/test/java/AppTest.java`. En el editor, reemplace el contenido actual del archivo por el siguiente código y, a continuación, guarde el archivo `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 el archivo `build.gradle` para el proyecto. (Un archivo `build.gradle` define la configuración de un proyecto Gradle). Para ello, en la ventana **Environment (Entorno)**, abra el archivo `my-app/build.gradle`. En el editor, reemplace el contenido actual del archivo por el siguiente código y, a continuación, guarde el archivo `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'
```
El archivo `build.gradle` anterior incluye la configuración del proyecto que especifica declaraciones como las siguientes:
+ El `io.spring.dependency-management` complemento se usa para importar la lista de materiales (BOM) de AWS SDK para Java Maven para administrar AWS SDK para Java las dependencias del proyecto. `classpath`declara la versión que se va a utilizar. Para utilizar otra versión, reemplace este número de versión.
+ `com.amazonaws:aws-java-sdk-s3` incluye la parte de Amazon S3 de los archivos de la biblioteca de AWS SDK para Java . `mavenBom` declara la versión que se utilizará. Si desea utilizar otra versión, reemplace este número de versión.
## Paso 5: Configure la administración de AWS credenciales en su entorno
Cada vez que utilice el AWS SDK para Java para llamar a un AWS servicio, debe proporcionar un conjunto de AWS credenciales con la llamada. Estas credenciales determinan si AWS SDK para Java tiene los permisos adecuados para realizar esa llamada. Si las credenciales no cubren los permisos adecuados, la llamada no se realizará correctamente.
En este paso, se almacenan las credenciales dentro del entorno. Para ello, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
Para obtener más información, consulte [Configurar las credenciales y la región de AWS para el desarrollo](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) en la *Guía para desarrolladores de AWS SDK para Java *.
## Paso 6: Agrega el código AWS del SDK
En este paso, agregará código para interactuar con Amazon S3 y crear un bucket, enumerará los buckets disponibles y, a continuación, eliminará el bucket que acaba de crear.
En la ventana **Environment (Entorno)** abra el archivo `my-app/src/main/java/com/mycompany/app/App.java` para Maven o el archivo `my-app/src/main/java/App.java` para Gradle. En el editor, reemplace el contenido actual del archivo por el siguiente código y, a continuación, guarde el archivo `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());
}
}
}
```
## Paso 7: Compila y ejecuta el código del AWS SDK
Para ejecutar el código desde el paso anterior, ejecute los siguientes comandos desde el terminal. Estos comandos usan Maven o Gradle para crear un archivo JAR ejecutable para el proyecto y, a continuación, usan el ejecutador de Java para ejecutar el archivo JAR. El JAR se ejecuta con el nombre del bucket que se va a crear en Amazon S3 (por ejemplo`my-test-bucket`) y el ID de la AWS región en la que se va a crear el bucket como entrada (por ejemplo,`us-east-2`).
Para Maven, ejecute los siguientes comandos.
```
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 Gradle, ejecute los siguientes comandos.
```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```
Compare sus resultados con la siguiente salida.
```
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:
```
## Paso 8: Eliminación
Para evitar que se hagan cargos continuos a su AWS cuenta una vez que haya terminado de usar este ejemplo, debe eliminar el entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# Tutorial de C\$1\$1 para AWS Cloud9
Este tutorial le permite ejecutar código C\$1\$1 en un entorno de AWS Cloud9 desarrollo. El código también utiliza los recursos proporcionados por el [AWS SDK para C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/welcome.html), una biblioteca modular, multiplataforma y de código abierto que puede utilizar para conectarse a Amazon Web Services.
Si sigue este tutorial y crea este ejemplo, es posible que se le cobren cargos a su AWS cuenta. Entre estos se incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-cplusplus-prereqs)
+ [Paso 1: Instalar g\$1\$1 y los paquetes de desarrollo necesarios](#sample-cplusplus-install)
+ [Paso 2: Instalar CMake](#install-cmake)
+ [Paso 3: Obtener y compilar el SDK para C\$1\$1](#install-cmake)
+ [Paso 4: Crea archivos de C\$1\$1 y CMake Listas](#sample-cplusplus-sdk-code)
+ [Paso 5: Compilar y ejecutar el código de C\$1\$1](#build-and-run-cpp)
+ [Paso 6: limpiar](#sample-cplusplus-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar g\$1\$1 y los paquetes de desarrollo necesarios
Para compilar y ejecutar una aplicación de C\$1\$1, necesita una utilidad como `g++`, que sea un compilador de C\$1\$1 proporcionado por [GNU Complier Collection (GCC)](https://gcc.gnu.org/).
También tiene que agregar archivos de encabezado (paquetes `-dev`) para `libcurl`, `libopenssl`, `libuuid`, `zlib` y, de manera opcional, `libpulse` para obtener asistencia de Amazon Polly.
El proceso de instalación de las herramientas de desarrollo varía ligeramente en función de si se utiliza una instancia de Amazon Linux/Amazon Linux 2 o una instancia de Ubuntu.
------
#### [ Amazon Linux-based systems ]
Puedes comprobar si ya lo has `gcc` instalado ejecutando el siguiente comando en la AWS Cloud9 terminal:
```
g++ --version
```
Si `g++` no está instalado, puede instalarlo fácilmente como parte del grupo de paquetes denominado “Herramientas de desarrollo”. Estas herramientas se agregan a una instancia con el comando `yum groupinstall`:
```
sudo yum groupinstall "Development Tools"
```
Ejecute `g++ --version` de nuevo para confirmar que se ha instalado el compilador.
Ahora instale los paquetes para las bibliotecas requeridas mediante el administrador de paquetes del sistema:
```
sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
```
------
#### [ Ubuntu-based systems ]
Puede comprobar si ya lo ha `gcc` instalado ejecutando el siguiente comando en el AWS Cloud9 terminal:
```
g++ --version
```
Si GCC no está instalado, puede instalarlo en un sistema basado en Ubuntu mediante los siguientes comandos:
```
sudo apt update
sudo apt install build-essential
sudo apt-get install manpages-dev
```
Ejecute `g++ --version` de nuevo para confirmar que se ha instalado el compilador.
Ahora instale los paquetes para las bibliotecas requeridas mediante el administrador de paquetes del sistema:
```
sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
```
------
## Paso 2: Instalar CMake
Debe instalar la herramienta `cmake`, que automatiza el proceso de compilación de archivos ejecutables a partir del código fuente.
1. En la ventana del terminal del IDE, ejecute el siguiente comando para obtener el archivo requerido:
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
1. Extraiga los archivos del archivo y vaya al directorio que contiene los archivos desempaquetados:
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
1. A continuación, ejecute un script de arranque y ejecute los comandos siguientes para instalar `cmake`:
```
./bootstrap
make
sudo make install
```
1. Para confirmar que ha instalado la herramienta, ejecute el comando siguiente:
```
cmake --version
```
## Paso 3: Obtener y compilar el SDK para C\$1\$1
Para configurar el AWS SDK para C\$1\$1, puedes compilarlo tú mismo directamente desde la fuente o descargar las bibliotecas mediante un administrador de paquetes. Encontrarás detalles sobre las opciones disponibles en [Cómo empezar a usar el AWS SDK para C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html) en la *Guía para AWS SDK para C\$1\$1 desarrolladores*.
En esta muestra se explica cómo usar `git` para clonar el código fuente del SDK y `cmake` para crear el SDK para C\$1\$1.
1. Clone el repositorio remoto y obtenga todos los submódulos de Git repetidamente para su entorno de AWS Cloud9 ejecutando el siguiente comando en el terminal:
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. Navega hasta el nuevo `aws-sdk-cpp` directorio, crea un subdirectorio en el que compilar el AWS SDK para C\$1\$1 y, a continuación, navega hasta ese directorio:
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**nota**
Para ahorrar tiempo, en este paso se crea solo la sección Amazon S3 del AWS SDK para C\$1\$1. Si desea crear el SDK completo, omita el fragmento `-DBUILD_ONLY=s3` del comando `cmake`.
La creación del SDK para C\$1\$1 completo puede tardar más de una hora en completarse en función de los recursos informáticos disponibles para su instancia de Amazon EC2 o para su propio servidor.
Use `cmake` para compilar la sección Amazon S3 del SDK para C\$1\$1 en el directorio `sdk_build` mediante la ejecución del siguiente comando:
```
cmake .. -DBUILD_ONLY=s3
```
1. A continuación, ejecute el comando `make install` para que se pueda acceder al SDK creado:
```
sudo make install
cd ..
```
## Paso 4: Crea archivos de C\$1\$1 y CMake Listas
En este paso va a crear un archivo de `C++` que permita a los usuarios del proyecto interactuar con los buckets de Amazon S3.
También puede crear un archivo `CMakeLists.txt` con instrucciones que `cmake` utiliza para crear su biblioteca de C\$1\$1.
1. En el AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre `s3-demo.cpp` en la raíz (`/`) de su entorno.
```
#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. Cree un archivo con este contenido y guárdelo con el nombre `CMakeLists.txt` en la raíz (`/`) de su entorno. Este archivo le permite compilar el código en un archivo ejecutable.
```
# 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})
```
## Paso 5: Compilar y ejecutar el código de C\$1\$1
1. En el directorio raíz de su entorno en el que ha guardado los archivos `s3-demo.cpp` y `CMakeLists.txt`, ejecute `cmake` para crear su proyecto:
```
cmake .
make
```
1. Ahora puede ejecutar el programa desde la línea de comandos. En el siguiente comando, reemplace `my-unique-bucket-name` por un nombre único para el bucket de Amazon S3 y, si es necesario, reemplace `us-east-1` por el identificador de otra región de AWS en la que desee crear un bucket.
```
./s3-demo my-unique-bucket-name us-east-1
```
Si el programa se ejecuta correctamente, se devolverá un resultado similar al siguiente:
```
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.
```
## Paso 6: limpiar
Para evitar que se hagan cargos continuos a su AWS cuenta una vez que haya terminado con este ejemplo, elimine el entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# Tutorial de Python para AWS Cloud9
Este tutorial muestra cómo ejecutar código Python en un entorno de AWS Cloud9 desarrollo.
Si sigue este tutorial, es posible que se le cobren cargos a su AWS cuenta. Entre estos se incluyen posibles cargos por servicios como Amazon Elastic Compute Cloud (Amazon EC2) y Amazon Simple Storage Service (Amazon S3). Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-python-prereqs)
+ [Paso 1: Instalar Python](#sample-python-install)
+ [Paso 2: Agregar el código](#sample-python-code)
+ [Paso 3: Ejecutar el código](#sample-python-run)
+ [Paso 4: Instale y configure el AWS SDK para Python (Boto3)](#sample-python-sdk)
+ [Paso 5: Agrega el código AWS del SDK](#sample-python-sdk-code)
+ [Paso 6: ejecuta el código AWS del SDK](#sample-python-sdk-run)
+ [Paso 7: limpiar](#sample-python-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que cumple los siguientes requisitos.
+ **Dispone de un entorno AWS Cloud9 de desarrollo EC2**
En este tutorial se da por hecho que tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Para obtener más información, consulte [Crear un entorno EC2](create-environment-main.md).
Si tiene un tipo de entorno o sistema operativo distinto, es posible que tenga que adaptar las instrucciones de este tutorial.
+ **Ha abierto el AWS Cloud9 IDE para ese entorno**
Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar Python
1. En una sesión de terminal en el AWS Cloud9 IDE, ejecute el **`python --version`**comando para confirmar si Python ya está instalado. (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**). Si Python está instalado, vaya directamente a [Paso 2: Agregar el código](#sample-python-code).
1. Ejecute el comando ** `yum update`** (para Amazon Linux) o ** `apt update` ** (para Ubuntu Server) para garantizar que las últimas actualizaciones de seguridad y correcciones de errores están instaladas.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Instale Python mediante la ejecución del comando ** `install` **.
Para Amazon Linux:
```
sudo yum -y install python3
```
Para Ubuntu Server:
```
sudo apt-get install python3
```
## Paso 2: Agregar el código
En el AWS Cloud9 IDE, cree un archivo con el siguiente contenido y guárdelo con ese nombre`hello.py`. (Para crear un archivo, en la barra de menús, elija **File** [Archivo], **New File** [Archivo nuevo]. Para guardar el archivo, elija **File** [Archivo], **Save** [Guardar]).
```
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))
```
## Paso 3: Ejecutar el código
1. En el AWS Cloud9 IDE, en la barra de menús, seleccione **Ejecutar**, **Ejecutar configuraciones** y **Nueva configuración de ejecución**.
1. En la pestaña **[New] - Stopped ([Nuevo] - Detenido)**, introduzca `hello.py 5 9` en **Command (Comando)**. En el código, `5` representa `sys.argv[1]` y `9` representa `sys.argv[2]`.
1. Elija **Run (Ejecutar)** y compare los resultados.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
1. De forma predeterminada, selecciona AWS Cloud9 automáticamente un ejecutor para el código. Para cambiar el ejecutor, seleccione **Runner (Ejecutor)** y, a continuación, seleccione **Python 2** o **Python 3**.
**nota**
Puede crear ejecutores personalizados para versiones específicas de Python. Para obtener más información, consulte [Crear un compilador o ejecutor](build-run-debug.md#build-run-debug-create-builder-runner).
## Paso 4: Instale y configure el AWS SDK para Python (Boto3)
AWS SDK para Python (Boto3) Le permite usar código Python para interactuar con AWS servicios como Amazon S3. Por ejemplo, puede utilizar el SDK para crear un bucket de Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket que acaba de crear.
### Instalar pip
En el AWS Cloud9 IDE, confirme si ya `pip` está instalada para la versión activa de Python ejecutando el **`python -m pip --version`**comando. Si `pip` está instalado, vaya a la siguiente sección.
Para instalar `pip`, ejecute los siguientes comandos. Dado que sudo se encuentra en un entorno diferente al del usuario, tiene que especificar la versión de Python que va a utilizar si difiere de la versión con alias actual.
```
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 obtener más información, consulte [Instalación](https://pip.pypa.io/en/stable/installing/) en el sitio web de `pip`.
### Instale el AWS SDK para Python (Boto3)
Tras la instalación`pip`, instálelo AWS SDK para Python (Boto3) ejecutando el **`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 obtener más información, consulte la sección "Instalación" de la [guía de inicio rápido](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) de AWS SDK para Python (Boto3).
### Configurar las credenciales en su entorno
Cada vez que utilice el AWS SDK para Python (Boto3) para llamar a un AWS servicio, debe proporcionar un conjunto de credenciales con la llamada. Estas credenciales determinan si el SDK tiene los permisos necesarios para realizar la llamada. Si las credenciales no abarcan los permisos necesarios, se produce un error en la llamada.
Para almacenar sus credenciales en el entorno, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
Para obtener información adicional, consulte [Credenciales](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html) en la AWS SDK para Python (Boto3).
## Paso 5: Agrega el código AWS del SDK
Agregue el código que utiliza Amazon S3 para crear un bucket, enumere los buckets disponibles y, de forma opcional, elimine el bucket que acaba de crear.
En el AWS Cloud9 IDE, cree un archivo con el siguiente contenido y guárdelo con ese nombre`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()
```
## Paso 6: ejecuta el código AWS del SDK
1. En la barra de menú, elija **Run** (Ejecutar), **Run Configurations** (Configuraciones de ejecución), **New Run Configuration** (Nueva configuración de ejecución).
1. En **Command**`s3.py my-test-bucket us-west-2`, introduce «dónde» `my-test-bucket` es el nombre del depósito que quieres crear y `us-west-2` el ID de la AWS región en la que se ha creado el depósito. De forma predeterminada, el bucket se elimina antes de que el script salga. Para conservar el bucket, añada `--keep_bucket` al comando. Para obtener una lista de AWS regiones IDs, consulte los [puntos de conexión y las cuotas de Amazon Simple Storage Service](https://docs.aws.amazon.com/general/latest/gr/s3.html) en. *Referencia general de AWS*
**nota**
Los nombres de los buckets de Amazon S3 deben ser únicos en todas AWS las AWS cuentas, no solo en ellas.
1. Elija **Run (Ejecutar)** y compare los resultados.
```
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
```
## Paso 7: limpiar
Para evitar que se hagan cargos continuos a tu AWS cuenta una vez que hayas terminado con este tutorial, elimina el AWS Cloud9 entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# Tutorial de.NET para AWS Cloud9
Este tutorial le permite ejecutar código de.NET en un entorno de AWS Cloud9 desarrollo.
Si sigue este tutorial y crea este ejemplo, es posible que se le cobren cargos a su AWS cuenta. Entre estos se incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-dotnetcore-prereqs)
+ [Paso 1: Instalar las herramientas necesarias](#sample-dotnetcore-setup)
+ [Paso 2 (opcional): Instalar la extensión de la CLI de .NET para las funciones de Lambda](#sample-dotnetcore-lambda)
+ [Paso 3: Crear un proyecto de aplicación de consola de .NET](#sample-dotnetcore-app)
+ [Paso 4: Agregar el código](#sample-dotnetcore-code)
+ [Paso 5: Compilar y ejecutar el código](#sample-dotnetcore-run)
+ [Paso 6: Cree y configure un proyecto de aplicación de consola .NET que utilice AWS SDK para .NET](#sample-dotnetcore-sdk)
+ [Paso 7: Añadir el código AWS del SDK](#sample-dotnetcore-sdk-code)
+ [Paso 8: Compila y ejecuta el código del AWS SDK](#sample-dotnetcore-sdk-run)
+ [Paso 9: limpiar](#sample-dotnetcore-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar las herramientas necesarias
En este paso, debe instalar el SDK de .NET en su entorno, lo cual es necesario para ejecutar esta muestra.
1. Confirme si la versión más reciente del SDK de .NET ya está instalada en su entorno. Para ello, en una sesión de terminal en el AWS Cloud9 IDE, ejecute la interfaz de línea de comandos (CLI) .NET Core con la **`--version`**opción.
```
dotnet --version
```
Si se muestra la versión de las herramientas de la línea de comandos de .NET y es la versión 2.0 o posterior, vaya a [Paso 3: Crear un proyecto de aplicación de consola de .NET](#sample-dotnetcore-app). Si la versión es anterior a 2.0, o si se muestra un error como `bash: dotnet: command not found`, continúe con la instalación del SDK de .NET.
1. En el caso de Amazon Linux, en una sesión de terminal en el AWS Cloud9 IDE, ejecute los siguientes comandos para garantizar la instalación de las últimas actualizaciones de seguridad y correcciones de errores, y para instalar el `libunwind` paquete que necesite el SDK de.NET. [Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window, New Terminal (Ventana, Nuevo terminal)**].
```
sudo yum -y update
sudo yum -y install libunwind
```
En el caso de Ubuntu Server, en una sesión de terminal en el AWS Cloud9 IDE, ejecute el siguiente comando para asegurarse de que estén instaladas las últimas actualizaciones de seguridad y correcciones de errores. [Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window, New Terminal (Ventana, Nuevo terminal)**].
```
sudo apt -y update
```
1. Descargue el script de instalación del SDK de .NET en el entorno ejecutando el siguiente comando.
```
wget https://dot.net/v1/dotnet-install.sh
```
1. Haga que el script de instalación sea ejecutable por el usuario actual mediante la ejecución del siguiente comando.
```
sudo chmod u=rx dotnet-install.sh
```
1. Ejecute el script de instalación, que descarga e instala el SDK de .NET, mediante la ejecución del siguiente comando.
```
./dotnet-install.sh -c Current
```
1. Agregue el SDK de .NET a su `PATH`. Para ello, en el perfil de shell del entorno (por ejemplo, el archivo `.bashrc`), agregue el subdirectorio `$HOME/.dotnet` a la variable `PATH` del entorno, como se indica a continuación.
1. Abra el archivo `.bashrc` para editarlo mediante el comando ** `vi` **.
```
vi ~/.bashrc
```
1. Para Amazon Linux, con la flecha hacia abajo o la tecla `j`, vaya a la línea que comienza por `export PATH`.
Para Ubuntu Server, vaya a la última línea del archivo escribiendo `G`.
1. Con la flecha derecha o la tecla `$`, vaya al final de esa línea.
1. Cambie a modo de inserción pulsando la tecla `i`. (Aparecerá `-- INSERT ---` al final de la pantalla).
1. Para Amazon Linux, agregue el subdirectorio `$HOME/.dotnet` a la variable ** `PATH` **, para lo cual debe escribir `:$HOME/.dotnet`. Asegúrese de incluir el carácter de dos puntos (`:`). La línea ahora debería tener un aspecto similar al siguiente.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
Para Ubuntu Server, pulse la tecla de flecha derecha, pulse `Enter` dos veces y, a continuación, escriba la siguiente línea sola al final del archivo.
```
export PATH=$HOME/.dotnet:$PATH
```
1. Guarde el archivo. Para ello, pulse la tecla `Esc` (desaparecerá `-- INSERT ---` desde el final de la pantalla), escriba `:wq` (para escribir y, a continuación, salir del archivo) y, a continuación, pulse `Enter`.
1. Cargue el SDK de .NET mediante el aprovisionamiento del archivo `.bashrc`.
```
. ~/.bashrc
```
1. Confirme que el SDK de .NET está cargado mediante la ejecución de la CLI de .NET con la opción ** `--help` **.
```
dotnet --help
```
Si se ejecuta correctamente, se muestra el número de versión del SDK de .NET, con información de uso adicional.
1. Si ya no desea mantener el script de instalación del SDK de .NET en su entorno, puede eliminarlo del siguiente modo.
```
rm dotnet-install.sh
```
## Paso 2 (opcional): Instalar la extensión de la CLI de .NET para las funciones de Lambda
Aunque no es obligatorio para este tutorial, puede implementar AWS Lambda funciones y AWS Serverless Application Model aplicaciones mediante la CLI de.NET si también instala el `Amazon.Lambda.Tools` paquete.
1. Para instalar este paquete, ejecute el comando siguiente:
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Ahora configure la propiedad `PATH` y la variable de entorno `DOTNET_ROOT` para que apunten a la herramienta Lambda instalada. En el archivo `.bashrc`, busque la sección `export PATH` y edítela para que se parezca a la siguiente (consulte el Paso 1 para obtener más detalles sobre la edición de este archivo):
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```
## Paso 3: Crear un proyecto de aplicación de consola de .NET
En este paso, se utiliza .NET para crear un proyecto denominado `hello`. Este proyecto contiene todos los archivos que necesita .NET para ejecutar una aplicación simple desde el terminal en el IDE. El código de la aplicación está escrito en C\$1.
Cree un proyecto de aplicación de consola de .NET. Para ello, ejecute la CLI de .NET con el comando ** `new` **, especificando el tipo de plantilla de proyecto de aplicación de consola y el lenguaje de programación que se utilizará (en esta muestra, C\$1).
La opción `-n` indica que el proyecto se emite en un nuevo directorio, `hello`. A continuación, vaya a ese directorio.
```
dotnet new console -lang C# -n hello
cd hello
```
El comando anterior añade un subdirectorio llamado `obj` con varios archivos, y algunos archivos independientes adicionales, al directorio `hello`. Debe tener en cuenta los dos archivos clave siguientes:
+ El archivo `hello/hello.csproj` contiene información sobre el proyecto de aplicación de consola.
+ El archivo `hello/Program.cs` contiene el código de la aplicación que se ejecutará.
## Paso 4: Agregar el código
En este paso, añadirá código a la aplicación.
En la ventana **Entorno** del AWS Cloud9 IDE, abra el `hello/Program.cs` archivo.
En el editor, reemplace el contenido actual del archivo por el siguiente código y, a continuación, guarde el archivo `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);
}
}
}
```
## Paso 5: Compilar y ejecutar el código
En este paso, compilará el proyecto y sus dependencias en un conjunto de archivos binarios, incluido un archivo de aplicación ejecutable. A continuación, ejecutará la aplicación.
1. En el IDE, cree un constructor para .NET de la siguiente manera.
1. En la barra de menús, seleccione **Run, Build System, New Build System (Ejecutar, Sistema de compilación, Nuevo sistema de compilación)**.
1. En la pestaña **My Builder.build (Mi Builder.build)**, reemplace el contenido de la pestaña por el código siguiente.
```
{
"cmd" : ["dotnet", "build"],
"info" : "Building..."
}
```
1. Elija **File, Save As (Archivo, Guardar como)**.
1. En **Filename (Nombre de archivo)**, escriba `.NET.build`.
1. En **Folder (Carpeta)**, escriba `/.c9/builders`.
1. Seleccione **Save**.
1. Con el contenido del archivo `Program.cs` mostrado en el editor, seleccione **Ejecutar, Sistema de compilación, .NET**. A continuación, elija **Run, Build (Ejecutar, Compilar)**.
Este constructor añade los subdirectorios `bin` y `Debug` al subdirectorio `hello/obj`. Tenga en cuenta los siguientes tres archivos clave.
+ El archivo `hello/bin/Debug/netcoreapp3.1/hello.dll` es el archivo de aplicación ejecutable.
+ El archivo `hello/bin/Debug/netcoreapp3.1/hello.deps.json` enumera las dependencias de la aplicación.
+ El archivo `hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json` especifica el tiempo de ejecución compartido y su versión para la aplicación.
**nota**
El nombre de la carpeta, `netcoreapp3.1`, refleja la versión del SDK de .NET. Es posible que vea un número diferente en el nombre de la carpeta dependiendo de la versión que haya instalado.
1. Cree un ejecutor para .NET de la siguiente manera.
1. En la barra de menús, seleccione **Run, Run With, New Runner (Ejecutar, Ejecutar con, Nuevo ejecutor)**.
1. En la pestaña **My Runner.run (Mi Runner.run)**, reemplace el contenido de la pestaña por el código siguiente.
```
{
"cmd" : ["dotnet", "run", "$args"],
"working_dir": "$file_path",
"info" : "Running..."
}
```
1. Elija **File, Save As (Archivo, Guardar como)**.
1. En **Filename (Nombre de archivo)**, escriba `.NET.run`.
1. En **Folder (Carpeta)**, escriba `/.c9/runners`.
1. Seleccione **Save**.
1. Ejecute la aplicación con dos números enteros que se añadirán (por ejemplo, `5` y `9`) de la siguiente manera.
1. Con el contenido del archivo `Program.cs` mostrado en el editor, seleccione **Run, Run Configurations, New Run Configuration (Ejecutar, Configuraciones de ejecución, Nueva configuración de ejecución)**.
1. En la pestaña **Nuevo - Inactivo**, elija **Ejecutor: automático** y, a continuación, elija **.NET**.
1. En el cuadro **Command (Comando)**, escriba `hello 5 9`.
1. Seleccione **Ejecutar**.
De forma predeterminada, este ejecutor indica a .NET que ejecute el archivo `hello.dll` en el directorio `hello/bin/Debug/netcoreapp3.1`.
Compare la salida con la siguiente.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Paso 6: Cree y configure un proyecto de aplicación de consola .NET que utilice AWS SDK para .NET
Puede mejorar este ejemplo para usarlo AWS SDK para .NET para crear un bucket de Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket que acaba de crear.
En este nuevo proyecto, añada una referencia al AWS SDK para .NET. AWS SDK para .NET Proporciona una forma cómoda de interactuar con AWS servicios como Amazon S3, desde su código.NET. A continuación, debe configurar la administración de AWS credenciales en su entorno. AWS SDK para .NET Necesita estas credenciales para interactuar con AWS los servicios.
### Para crear el proyecto
1. Cree un proyecto de aplicación de consola de .NET. Para ello, ejecute la CLI de .NET con el comando ** `new` **, especificando el tipo de plantilla de proyecto de aplicación de consola y el lenguaje de programación que se utilizará.
La opción `-n` indica que el proyecto se emite en un nuevo directorio, `s3`. A continuación, vaya a ese directorio.
```
dotnet new console -lang C# -n s3
cd s3
```
1. Agregue una referencia de proyecto al paquete de Amazon S3 en AWS SDK para .NET. Para ello, ejecute la CLI.NET con el **`add package`**comando, especificando el nombre del paquete Amazon S3 en NuGet. (NuGetdefine cómo se crean, alojan y consumen los paquetes para .NET, y proporciona las herramientas para cada una de esas funciones).
```
dotnet add package AWSSDK.S3
```
Al añadir una referencia de proyecto al paquete Amazon S3, NuGet también añade una referencia de proyecto al resto del AWS SDK para .NET.
**nota**
Para ver los nombres y las versiones de otros paquetes AWS relacionados NuGet, consulte [NuGetlos paquetes etiquetados con aws-sdk](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22) en el NuGet sitio web.
### Para configurar la administración de credenciales AWS
Cada vez que utilice el AWS SDK para .NET para llamar a un AWS servicio, debe proporcionar un conjunto de AWS credenciales con la llamada. Estas credenciales determinan si AWS SDK para .NET tiene los permisos adecuados para realizar esa llamada. Si las credenciales no cubren los permisos adecuados, la llamada no se realizará correctamente.
Para almacenar sus credenciales en el entorno, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
Para obtener información adicional, consulte [Configuración de AWS credenciales](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html) en la *Guía para AWS SDK para .NET desarrolladores*.
## Paso 7: Añadir el código AWS del SDK
En este paso, agregará código para interactuar con Amazon S3 y crear un bucket, eliminará el bucket que acaba de crear y, a continuación, enumerará los buckets disponibles.
Desde la ventana de **entorno** del AWS Cloud9 IDE, abra el `s3/Program.cs` archivo. En el editor, reemplace el contenido actual del archivo por el siguiente código y, a continuación, guarde el archivo `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);
}
}
}
}
}
```
## Paso 8: Compila y ejecuta el código del AWS SDK
En este paso, compilará el proyecto y sus dependencias en un conjunto de archivos binarios, incluido un archivo de aplicación ejecutable. A continuación, ejecutará la aplicación.
1. Compilar el proyecto. Para ello, con el contenido del archivo `s3/Program.cs` mostrado en el editor, en la barra de menú, elija **Run, Build (Ejecutar, Compilar)**.
1. Ejecute la aplicación con el nombre del bucket de Amazon S3 que desea crear y el ID de la región de `my-test-bucket` en la que desea crearlo (por ejemplo, AWS y `us-east-2`) de la siguiente manera.
1. Con el contenido del archivo `s3/Program.cs` aún mostrado en el editor, seleccione **Run, Run Configurations, New Run Configuration (Ejecutar, Configuraciones de ejecución, Nueva configuración de ejecución)**.
1. En la pestaña **Nuevo - Inactivo**, elija **Ejecutor: automático** y, a continuación, elija **.NET**.
1. En el cuadro de **comandos**, escriba el nombre de la aplicación, el nombre del bucket de Amazon S3 que se va a crear y el ID de la AWS región en la que se va a crear el bucket (por ejemplo,`s3 my-test-bucket us-east-2`).
1. Seleccione **Ejecutar**.
De forma predeterminada, este ejecutor indica a .NET que ejecute el archivo `s3.dll` en el directorio `s3/bin/Debug/netcoreapp3.1`.
Compare sus resultados con la siguiente salida.
```
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:
```
## Paso 9: limpiar
Para evitar que se hagan cargos continuos a su AWS cuenta una vez que haya terminado de usar este ejemplo, debe eliminar el entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# Tutorial de Node.js para AWS Cloud9
Este tutorial le permite ejecutar algunos scripts de Node.js en un entorno de AWS Cloud9 desarrollo.
Si sigue este tutorial y crea este ejemplo, es posible que se le cobren cargos a su AWS cuenta. Estos incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Amazon EC2 Pricing](https://aws.amazon.com/ec2/pricing/) y [Amazon S3 Pricing](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-nodejs-prereqs)
+ [Paso 1: Instalar las herramientas necesarias](#sample-nodejs-install)
+ [Paso 2: Agregar el código](#sample-nodejs-code)
+ [Paso 3: Ejecutar el código](#sample-nodejs-run)
+ [Paso 4: Instalar y configurar el AWS SDK para JavaScript Node.js](#sample-nodejs-sdk)
+ [Paso 5: Agrega el código AWS del SDK](#sample-nodejs-sdk-code)
+ [Paso 6: ejecuta el código AWS del SDK](#sample-nodejs-sdk-run)
+ [Paso 7: limpiar](#sample-nodejs-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de AWS Cloud9 EC2 desarrollo existente.** En este ejemplo se supone que ya tienes un EC2 entorno conectado a una EC2 instancia de Amazon que ejecuta Amazon Linux o Ubuntu Servidor. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar las herramientas necesarias
En este paso instalará Node.js, necesario para ejecutar esta muestra.
1. En una sesión de terminal en el AWS Cloud9 IDE, ejecute el **`node --version`**comando para confirmar si Node.js ya está instalado. (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**). Si es así, el resultado contendrá el número de versión de Node.js. Si Node.js está instalado, continúe en [Paso 2: Agregar el código](#sample-nodejs-code).
1. Ejecute el comando ** `yum update` ** (para Amazon Linux) o ** `apt update` ** (para Ubuntu Server) para garantizar que las últimas actualizaciones de seguridad y correcciones de errores están instaladas.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Para instalar Node.js, comience por ejecutar este comando para descargar Node Version Manager (nvm). (nvm) es un sencillo script de shell de Bash que resulta útil para instalar y administrar las versiones de Node.js. Para obtener más información, consulte el [administrador de versiones de Node](https://github.com/creationix/nvm/blob/master/README.md) en el sitio GitHub web.)
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
```
1. Para comenzar a utilizar nvm, cierre la sesión del terminal e iníciela de nuevo, o cargue el archivo `~/.bashrc` que contiene los comandos para cargar nvm.
```
. ~/.bashrc
```
1. Ejecute este comando para instalar Node.js 16 en Amazon Linux 2, Amazon Linux 1 y Ubuntu 18.04. Las instancias de Amazon Linux 1 y Ubuntu 18.04 solo admiten Node.js hasta la v16.
```
nvm install 16
```
Ejecute este comando para instalar la última versión de Node.js en Amazon Linux 2023 y Ubuntu 22.04:
```
nvm install --lts && nvm alias default lts/*
```
**nota**
La última AWS Cloud9 imagen de AL2 023 tiene instalado Node.js 20 y la AWS Cloud9 imagen más reciente de Amazon Linux 2 tiene instalado Node.js 18. Si desea instalar Node.js 18 en Amazon Linux 2 AWS Cloud9 manualmente, ejecute el siguiente comando en la terminal 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
```
## Paso 2: Agregar el código
En el AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre`hello.js`. (Para crear un archivo, en la barra de menús, elija **File** [Archivo], **New File** [Archivo nuevo]. Para guardar el archivo, elija **File** [Archivo], **Save** [Guardar]).
```
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 + '.');
```
## Paso 3: Ejecutar el código
1. En el AWS Cloud9 IDE, en la barra de menús, seleccione **Ejecutar**, **Ejecutar configuraciones**, **Nueva configuración de ejecución**.
1. En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **Node.js**.
1. En **Command (Comando)**, escriba `hello.js 5 9`. En el código, `5` representa `process.argv[2]` y `9` representa `process.argv[3]`. (`process.argv[0]` representa el nombre del tiempo de ejecución (`node`) y `process.argv[1]` representa el nombre del archivo (`hello.js`)).
1. Elija el botón **Run (Ejecutar)** y compare los resultados.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Salida de Node.js después de ejecutar el código en el AWS Cloud9 IDE\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## Paso 4: Instalar y configurar el AWS SDK para JavaScript Node.js
Al ejecutar los scripts de Node.js AWS Cloud9, puede elegir entre el AWS SDK para la JavaScript versión 3 (V3) y el AWS SDK anterior para la JavaScript versión 2 (V2). Al igual que con la versión 2, la versión 3 le permite trabajar fácilmente con Amazon Web Services, pero se ha incorporado TypeScript y añade varias funciones solicitadas con frecuencia, como los paquetes modularizados.
------
#### [ AWS SDK for JavaScript (V3) ]
Puede mejorar este ejemplo para usar el AWS SDK de Node.js para JavaScript crear un bucket de Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket que acaba de crear.
En este paso, debe instalar y configurar el módulo cliente de servicio Amazon S3 del AWS SDK para JavaScript Node.js, que proporciona una forma cómoda de interactuar con el AWS servicio Amazon S3 desde su JavaScript código.
Si desea utilizar otros AWS servicios, debe instalarlos por separado. Para obtener más información sobre la instalación de AWS módulos, consulte [la *Guía para AWS desarrolladores (V3).*](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/working-with-services) Para obtener información sobre cómo empezar a utilizar Node.js y el AWS SDK para JavaScript (V3), consulte Cómo [empezar a utilizar Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure) en la *Guía del AWS SDK para JavaScript desarrolladores (V3*).
Tras instalar el AWS SDK para JavaScript Node.js, debe configurar la administración de credenciales en su entorno. El AWS SDK JavaScript de Node.js necesita estas credenciales para interactuar con AWS los servicios.
**Para instalar el AWS SDK JavaScript en Node.js**
Use npm para ejecutar el comando **`install`**.
```
npm install @aws-sdk/client-s3
```
Para obtener más información, consulte [Instalación del SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html#installing-jssdk) en la *Guía para AWS SDK para JavaScript desarrolladores*.
**Para configurar la administración de credenciales en el entorno**
Cada vez que utilices el AWS SDK JavaScript de Node.js para llamar a un AWS servicio, debes proporcionar un conjunto de credenciales con la llamada. Estas credenciales determinan si el AWS SDK JavaScript de Node.js tiene los permisos adecuados para realizar esa llamada. Si las credenciales no cubren los permisos adecuados, la llamada no se realizará correctamente.
En este paso, se almacenan las credenciales dentro del entorno. Para ello, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
Para obtener información adicional, consulte [Configuración de credenciales en Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) en la *Guía para desarrolladores de AWS SDK para JavaScript *.
------
#### [ AWS SDK for JavaScript (V2) ]
Puede mejorar este ejemplo para usar el AWS SDK de Node.js para JavaScript crear un bucket de Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket que acaba de crear.
En este paso, instalará y configurará el AWS SDK para JavaScript Node.js, que proporciona una forma cómoda de interactuar con AWS servicios como Amazon S3 desde su JavaScript código. Tras instalar el AWS SDK JavaScript en Node.js, debe configurar la administración de credenciales en su entorno. El AWS SDK JavaScript de Node.js necesita estas credenciales para interactuar con AWS los servicios.
**Para instalar el AWS SDK JavaScript en Node.js**
Use npm para ejecutar el comando **`install`**.
```
npm install aws-sdk
```
Para obtener más información, consulte [Instalación del SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) en la *Guía para AWS SDK para JavaScript desarrolladores*.
**Para configurar la administración de credenciales en el entorno**
Cada vez que utilices el AWS SDK JavaScript de Node.js para llamar a un AWS servicio, debes proporcionar un conjunto de credenciales con la llamada. Estas credenciales determinan si el AWS SDK JavaScript de Node.js tiene los permisos adecuados para realizar esa llamada. Si las credenciales no cubren los permisos adecuados, la llamada no se realizará correctamente.
En este paso, se almacenan las credenciales dentro del entorno. Para ello, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
Para obtener información adicional, consulte [Configuración de credenciales en Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) en la *Guía para desarrolladores de AWS SDK para JavaScript *.
------
## Paso 5: Agrega el código AWS del SDK
------
#### [ AWS SDK for JavaScript (V3) ]
En este paso, agregará algo más de código, esta vez para interactuar con Amazon S3 y crear un bucket, ver una lista de los buckets disponibles y después eliminar el bucket que acaba de crear. Ejecutará este código más adelante.
En el AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre`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) ]
En este paso, agregará algo más de código, esta vez para interactuar con Amazon S3 y crear un bucket, ver una lista de los buckets disponibles y después eliminar el bucket que acaba de crear. Ejecutará este código más adelante.
En el AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre`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,
]);
```
------
## Paso 6: ejecuta el código AWS del SDK
1. Habilite el código para llamar a las operaciones de Amazon S3 de forma asincrónica mediante la utilización de npm para ejecutar el comando ** `install` **.
```
npm install async
```
1. En el AWS Cloud9 IDE, en la barra de menús, elija **Ejecutar**, **Ejecutar configuraciones**, **Nueva configuración de ejecución**.
1. En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **Node.js**.
1. Si utiliza el AWS SDK para JavaScript (V3), en Tipo `s3.js` de **comando**. Si utilizas el AWS SDK para Javascript (v2), para el tipo de **comando**`s3.js my-test-bucket us-east-2`, donde `my-test-bucket` aparece el nombre del bucket que quieres crear y, después, eliminar, y `us-east-2` el ID de la AWS región en la que quieres crear el bucket. Para obtener más información IDs, consulte [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) en. *Referencia general de Amazon Web Services*
**nota**
Los nombres de los buckets de Amazon S3 deben ser únicos en todas AWS las AWS cuentas, no solo en ellas.
1. Elija el botón **Run (Ejecutar)** y compare los resultados.
```
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:
```
## Paso 7: limpiar
Para evitar que se hagan cargos continuos a tu AWS cuenta una vez que hayas terminado de usar este ejemplo, debes eliminar el entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# Tutorial de PHP para AWS Cloud9
Este tutorial le permite ejecutar algunos scripts PHP en un entorno de AWS Cloud9 desarrollo.
El uso de este tutorial y la creación de esta muestra pueden generar cargos en su cuenta de AWS . Entre estos se incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-php-prereqs)
+ [Paso 1: Instalar las herramientas necesarias](#sample-php-install)
+ [Paso 2: Agregar el código](#sample-php-code)
+ [Paso 3: Ejecutar el código](#sample-php-run)
+ [Paso 4: Instalar y configurar el AWS SDK para PHP](#sample-php-sdk)
+ [Paso 5: Agrega el código AWS del SDK](#sample-php-sdk-code)
+ [Paso 6: ejecuta el código AWS del SDK](#sample-php-sdk-run)
+ [Paso 7: limpiar](#sample-php-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar las herramientas necesarias
En este paso, instalará PHP, que es necesario para ejecutar este ejemplo.
**nota**
El siguiente procedimiento instala solo PHP. Para instalar herramientas relacionadas como, por ejemplo, un servidor web Apache y una base de datos MySQL, consulte el [Tutorial: Installing a LAMP Web Server on Amazon Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-LAMP.html) en la *Guía del usuario de Amazon EC2*.
1. En una sesión de terminal en el AWS Cloud9 IDE, ejecute el **`php --version`**comando para confirmar si PHP ya está instalado. (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**). Si es así, el resultado contendrá el número de versión de PHP. Si PHP está instalado, continúe en [Paso 2: Agregar el código](#sample-php-code).
1. Ejecute el comando ** `yum update` ** (para Amazon Linux) o ** `apt update` ** (para Ubuntu Server) para garantizar que las últimas actualizaciones de seguridad y correcciones de errores están instaladas.
Para Amazon Linux 2 y Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Instale PHP ejecutando el comando ** `install` **.
En Amazon Linux 2:
```
sudo amazon-linux-extras install -y php7.2
```
Para Amazon Linux:
```
sudo yum -y install php72
```
**nota**
Puede ver la versión de Amazon Linux usando el comando siguiente:
```
cat /etc/system-release
```
Para Ubuntu Server:
```
sudo apt install -y php php-xml
```
Para obtener más información, consulte [Installation and Configuration](http://php.net/manual/en/install.php) en el sitio web de PHP.
## Paso 2: Agregar el código
En el AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre`hello.php`. (Para crear un archivo, en la barra de menús, elija **File** [Archivo], **New File** [Archivo nuevo]. Para guardar el archivo, elija**File** [Archivo], **Save** [Guardar], escriba `hello.php` para **Filename** [Nombre de archivo] y, a continuación, elija **Save** [Guardar]).
```
```
**nota**
El código anterior no depende de archivos externos. Sin embargo, si alguna vez incluyes o requieres otros archivos PHP en tu archivo y quieres usarlos AWS Cloud9 para completar código mientras escribes, activa la configuración **Proyecto, Soporte PHP, Habilitar finalización de código PHP** en **Preferencias** y, a continuación, añade las rutas a esos archivos a la configuración **Proyecto, Soporte PHP, Integración de rutas de finalización de PHP**. (Para ver y cambiar las preferencias, elija **AWS Cloud9, Preferences** [AWS Cloud9, Preferencias] en la barra de menús).
## Paso 3: Ejecutar el código
1. En el AWS Cloud9 IDE, en la barra de menús, selecciona **Ejecutar**, **Ejecutar configuraciones**, **Nueva configuración de ejecución**.
1. En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **PHP (cli)**.
1. En **Command (Comando)**, escriba `hello.php 5 9`. En el código, `5` representa `$argv[1]` y `9` representa `$argv[2]`. (`$argv[0]` representa el nombre del archivo (`hello.php`).)
1. Elija el botón **Run (Ejecutar)** y compare los resultados.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Resultado de la ejecución del código PHP en el AWS Cloud9 IDE\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/images/ide-php-simple.png)
## Paso 4: Instalar y configurar el AWS SDK para PHP
Puede mejorar este ejemplo para usarlo AWS SDK para PHP para crear un bucket de Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket que acaba de crear.
En este paso, debe instalar y configurar AWS SDK para PHP, lo que proporciona una forma cómoda de interactuar con AWS servicios como Amazon S3, desde su código PHP. Antes de poder instalar el AWS SDK para PHP, debe instalar [Composer](https://getcomposer.org/). Tras instalar el AWS SDK para PHP, debe configurar la administración de credenciales en su entorno. AWS SDK para PHP Necesita estas credenciales para interactuar con AWS los servicios.
### Para instalar Composer
Ejecute el comando ** `curl` ** con las opciones de silenciar (`-s`) y mostrar errores (`-S`), canalizando el instalador de Composer a un archivo PHP (PHAR), cuyo nombre es `composer.phar` por convención.
```
curl -sS https://getcomposer.org/installer | php
```
### Para instalar el AWS SDK para PHP
Para Ubuntu Server, instale los paquetes adicionales que Composer necesita para instalar el AWS SDK para PHP.
```
sudo apt install -y php-xml php-curl
```
Para Amazon Linux o Ubuntu Server, use el comando **php** para ejecutar el instalador de Composer para instalar el AWS SDK para PHP.
```
php composer.phar require aws/aws-sdk-php
```
Este comando crea varias carpetas y archivos en su entorno. El archivo principal que se va a utilizar es `autoload.php`, que está en la carpeta `vendor` de su entorno.
**nota**
Después de la instalación, Composer podría sugerir que se instalen dependencias adicionales. Puede hacerlo con un comando como los siguientes, especificando la lista de dependencias que desea instalar. Por ejemplo, el siguiente comando indica a Composer que instale la siguiente lista de dependencias.
```
php composer.phar require psr/log ext-curl doctrine/cache aws/aws-php-sns-message-validator
```
Para obtener más información, consulte [Instalación](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/installation.html) en la *Guía para desarrolladores de AWS SDK para PHP *.
### Para configurar la administración de credenciales en el entorno
Cada vez que utilice el AWS SDK para PHP para llamar a un AWS servicio, debe proporcionar un conjunto de credenciales con la llamada. Estas credenciales determinan si AWS SDK para PHP tiene los permisos adecuados para realizar esa llamada. Si las credenciales no cubren los permisos adecuados, la llamada no se realizará correctamente.
En este paso, se almacenan las credenciales dentro del entorno. Para ello, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
Para obtener información adicional, consulte la sección sobre creación de un cliente de [Uso básico](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/basic-usage.html) en la *Guía para desarrolladores de AWS SDK para PHP *.
## Paso 5: Agrega el código AWS del SDK
En este paso, agregará algo más de código, esta vez para interactuar con Amazon S3 y crear un bucket, ver una lista de los buckets disponibles y después eliminar el bucket que acaba de crear. Ejecutará este código más adelante.
En el AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre`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);
?>
```
## Paso 6: ejecuta el código AWS del SDK
1. En el AWS Cloud9 IDE, en la barra de menús, elija **Ejecutar**, **Ejecutar configuraciones**, **Nueva configuración de ejecución**.
1. En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **PHP (cli)**.
1. En **Command (Comando)**, escriba `s3.php America/Los_Angeles my-test-bucket us-east-2`, donde:
+ `America/Los_Angeles` es el ID de zona horaria predeterminado. Para obtener más información IDs, consulte [la lista de zonas horarias compatibles](http://php.net/manual/en/timezones.php) en el sitio web de PHP.
+ `my-test-bucket` es el nombre del bucket que desea crear y, a continuación, eliminar.
**nota**
Los nombres de los buckets de Amazon S3 deben ser únicos en todas AWS las AWS cuentas, no solo en ellas.
+ `us-east-2`es el ID de la AWS región en la que quieres crear el bucket. Para obtener más información IDs, consulte [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) en. *Referencia general de Amazon Web Services*
1. Elija el botón **Run (Ejecutar)** y compare los resultados.
```
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:
```
## Paso 7: limpiar
Para evitar que se sigan cobrando en tu AWS cuenta una vez que hayas terminado de usar este ejemplo, debes eliminar el entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
### Solución de problemas con el ejecutor de PHP para AWS Cloud9
En caso de que tenga problemas con el ejecutor CLI de PHP, debe asegurarse de que el ejecutor esté configurado en PHP y de que el modo de depuración esté habilitado.
# AWS SDK para Ruby en AWS Cloud9
Para obtener información sobre el uso AWS Cloud9 con el AWS SDK para Ruby, consulta [Uso AWS Cloud9 con el AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html) en la *Guía para desarrolladores de AWS SDK para Ruby*.
**nota**
Si sigue este tutorial, es posible que se le cobren cargos a su AWS cuenta. Estos incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Amazon EC2 Pricing](https://aws.amazon.com/ec2/pricing/) y [Amazon S3 Pricing](https://aws.amazon.com/s3/pricing/).
# Tutorial Go para AWS Cloud9
Este tutorial te permite ejecutar código de Go en un entorno de AWS Cloud9 desarrollo.
Si sigues este tutorial y creas este ejemplo, es posible que se hagan cargos en tu AWS cuenta. Entre estos se incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-go-prereqs)
+ [Paso 1: Instalar las herramientas necesarias](#sample-go-install)
+ [Paso 2: Agregar el código](#sample-go-code)
+ [Paso 3: Ejecutar el código](#sample-go-run)
+ [Paso 4: Instalar y configurar el AWS SDK para Go](#sample-go-sdk)
+ [Paso 5: Agrega el código AWS del SDK](#sample-go-sdk-code)
+ [Paso 6: ejecuta el código AWS del SDK](#sample-go-sdk-run)
+ [Paso 7: limpiar](#sample-go-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar las herramientas necesarias
En este paso, va a instalar y configurar Go, necesario para ejecutar este ejemplo.
1. En una sesión de terminal en el AWS Cloud9 IDE, ejecute el **`go version`**comando para confirmar si Go ya está instalado. (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**). Si se ejecuta correctamente, el resultado debería contener el número de versión de Go. De lo contrario, se debería obtener un mensaje de error como resultado. Si Go está instalado, continúe en [Paso 2: Agregar el código](#sample-go-code).
1. Ejecute el comando ** `yum update` ** (para Amazon Linux) o ** `apt update` ** (para Ubuntu Server) para garantizar que las últimas actualizaciones de seguridad y correcciones de errores están instaladas.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Para instalar Go, ejecute estos comandos de uno en uno.
```
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.
```
Los comandos anteriores suponen que se emplea la última versión estable de Go en el momento en que este tema se escribió. Para obtener más información, consulte [Downloads](https://golang.org/dl/) en el sitio web del lenguaje de programación Go.
1. Agregue la ruta de los binarios de Go a la variable de entorno `PATH`, como se muestra a continuación.
1. Abra el archivo de perfil de shell (por ejemplo, `~/.bashrc`) para editarlo.
1. Al final de esta línea de código, escriba lo siguiente, de forma que el código ahora pasará a tener este aspecto.
```
PATH=$PATH:/usr/local/go/bin
```
1. Guarde el archivo.
1. Dé el origen del archivo `~/.bashrc` para que el terminal pueda encontrar el binario de Go al que acaba de hacer referencia.
```
. ~/.bashrc
```
1. Confirme que Go ya está instalado y configurado correctamente ejecutando el comando ** `go version` **. Si es así, el resultado contendrá el número de versión de Go.
## Paso 2: Agregar el código
En el AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre`hello.go`. (Para crear un archivo, en la barra de menús, elija **File** [Archivo], **New File** [Archivo nuevo]. Para guardar el archivo, elija **File** [Archivo], **Save** [Guardar]).
```
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))
}
```
## Paso 3: Ejecutar el código
1. En el AWS Cloud9 IDE, en la barra de menús, seleccione **Ejecutar**, **Ejecutar configuraciones**, **Nueva configuración de ejecución**.
1. En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **Go**.
**nota**
Si **Go** no está disponible, puede crear un ejecutor personalizado para Go.
En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **New Runner (Ejecutor nuevo)**.
En la pestaña **My Runner.run (Mi Runner.run)**, sustituya el contenido de la pestaña por este código.
```
{
"cmd" : ["go", "run", "$file", "$args"],
"info" : "Running $project_path$file_name...",
"selector" : "source.go"
}
```
Elija **File (Archivo)**, **Save As (Guardar como)** en la barra de menús y guarde el archivo como `Go.run` en la carpeta `/.c9/runners`.
En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **Go**.
Elija la pestaña **hello.go** para hacerla activa.
1. En **Command (Comando)**, escriba `hello.go 5 9`. En el código, `5` representa `os.Args[1]` y `9` representa `os.Args[2]`.
![\[Resultado de la ejecución del código Go en el AWS Cloud9 IDE\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/images/ide-go-simple.png)
1. Elija el botón **Run (Ejecutar)** y compare los resultados.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Paso 4: Instalar y configurar el AWS SDK para Go
Puede mejorar este ejemplo para usarlo AWS SDK para Go para crear un bucket de Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket que acaba de crear.
En este paso, instalas y configuras el AWS SDK para Go, que proporciona una forma cómoda de interactuar con AWS servicios como Amazon S3, desde tu código Go. Antes de instalar el AWS SDK para Go, debe configurar la variable de entorno `GOPATH`. Una vez instalado el AWS SDK para Go y establecida la variable de entorno `GOPATH`, debe configurar la administración de credenciales en el entorno. AWS SDK para Go Necesita estas credenciales para interactuar con AWS los servicios.
### Para establecer la variable de entorno GOPATH
1. Abra el archivo `~/.bashrc` para editarlo.
1. Después de la última línea, escriba este código.
```
GOPATH=~/environment/go
export GOPATH
```
1. Guarde el archivo.
1. Dé el origen del archivo `~/.bashrc` para que el terminal pueda encontrar la variable de entorno `GOPATH` a la que acaba de hacer referencia.
```
. ~/.bashrc
```
1. Confirme que la variable de entorno `GOPATH` está establecida correctamente ejecutando el comando ** `echo $GOPATH` **. Si es correcto, el resultado debe ser `/home/ec2-user/environment/go` o `/home/ubuntu/environment/go`.
### Para instalar el AWS SDK para Go
Ejecute el **`go get`**comando especificando la ubicación de la AWS SDK para Go fuente.
```
go get -u github.com/aws/aws-sdk-go/...
```
Go instala la AWS SDK para Go fuente en la ubicación especificada por la variable de `GOPATH` entorno, que es la `go` carpeta de su entorno.
### Para configurar la administración de credenciales en el entorno
Cada vez que utilice el AWS SDK para Go para llamar a un AWS servicio, debe proporcionar un conjunto de credenciales con la llamada. Estas credenciales determinan si AWS SDK para Go tiene los permisos adecuados para realizar esa llamada. Si las credenciales no cubren los permisos adecuados, la llamada no se realizará correctamente.
En este paso, se almacenan las credenciales dentro del entorno. Para ello, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
Para obtener información adicional, consulte [Especificación de credenciales](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials) en la *Guía para desarrolladores de AWS SDK para Go *.
## Paso 5: Agrega el código AWS del SDK
En este paso, agregará algo más de código, esta vez para interactuar con Amazon S3 y crear un bucket, ver una lista de los buckets disponibles y después eliminar el bucket que acaba de crear. Ejecutará este código más adelante.
En el AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre`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)
}
```
## Paso 6: ejecuta el código AWS del SDK
1. En el AWS Cloud9 IDE, en la barra de menús, elija **Ejecutar**, **Ejecutar configuraciones**, **Nueva configuración de ejecución**.
1. En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **Go**.
1. En **Comando**`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `, escriba el nombre del depósito que desea crear y, a continuación, eliminar, y ` THE_AWS_REGION ` el ID de la AWS región en la que desea crear el depósito. ` YOUR_BUCKET_NAME ` Por ejemplo, para la región EE.UU. Este (Ohio), utilice `us-east-2`. Para obtener más información IDs, consulte [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) en. *Referencia general de Amazon Web Services*
**nota**
Los nombres de los buckets de Amazon S3 deben ser únicos en todas AWS las AWS cuentas, no solo en ellas.
1. Elija el botón **Run (Ejecutar)** y compare los resultados.
```
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:
```
## Paso 7: limpiar
Para evitar que se hagan cargos continuos a tu AWS cuenta una vez que hayas terminado de usar este ejemplo, debes eliminar el entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# TypeScript tutorial para AWS Cloud9
Este tutorial le muestra cómo trabajar con él TypeScript en un entorno de AWS Cloud9 desarrollo.
Si sigue este tutorial y crea este ejemplo, es posible que se le cobren cargos a su AWS cuenta. Entre estos se incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Requisitos previos](#sample-typescript-prereqs)
+ [Paso 1: Instalar las herramientas necesarias](#sample-typescript-install)
+ [Paso 2: Agregar el código](#sample-typescript-code)
+ [Paso 3: Ejecutar el código](#sample-typescript-run)
+ [Paso 4: Instalar y configurar el AWS SDK para JavaScript Node.js](#sample-typescript-sdk)
+ [Paso 5: Agrega el código AWS del SDK](#sample-typescript-sdk-code)
+ [Paso 6: ejecuta el código del SDK AWS](#sample-typescript-sdk-run)
+ [Paso 7: limpiar](#sample-typescript-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instalar las herramientas necesarias
En este paso, la instalación se TypeScript realiza mediante Node Package Manager (**`npm`**). Para instalar **`npm`**, use Node Version Manager (**`nvm`**). Si no tiene **`nvm`**, instálelo primero en este paso.
1. En una sesión de terminal en el AWS Cloud9 IDE, confirme si ya TypeScript está instalado ejecutando el TypeScript compilador de línea de comandos con la **`--version`**opción. (Para iniciar una nueva sesión del terminal, en la barra de menús, seleccione **Window [Ventana]**, **New Terminal [Nuevo terminal]**). Si se ejecuta correctamente, el resultado contiene el número de TypeScript versión. Si TypeScript está instalado, pase a[Paso 2: Agregar el código](#sample-typescript-code).
```
tsc --version
```
1. Confirme si **`npm`** ya está instalado mediante la ejecución de **`npm`** con la opción **`--version`**. Si es así, el resultado contendrá el número de versión de **`npm`**. Si **`npm`**está instalado, vaya al paso 10 de este procedimiento **`npm`**para utilizarlo en la instalación TypeScript.
```
npm --version
```
1. Ejecute el comando ** `yum update` ** (para Amazon Linux) o ** `apt update` ** (para Ubuntu Server) para garantizar que las últimas actualizaciones de seguridad y correcciones de errores están instaladas.
Para Amazon Linux:
```
sudo yum -y update
```
Para Ubuntu Server:
```
sudo apt update
```
1. Para instalarlo **`npm`**, comience por ejecutar el siguiente comando para descargar Node Version Manager (**`nvm`**). (**`nvm`**es un sencillo script de shell de Bash que resulta útil para instalar y administrar las versiones de Node.js. Para obtener más información, consulte el [administrador de versiones de Node](https://github.com/creationix/nvm/blob/master/README.md) en el GitHub sitio web.)
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Para comenzar a utilizar **`nvm`**, cierre la sesión del terminal e iníciela de nuevo, o cargue el archivo `~/.bashrc` que contiene los comandos para cargar **`nvm`**.
```
. ~/.bashrc
```
1. Confirme que **`nvm`** está instalado mediante la ejecución de **`nvm`** con la opción **`--version`**.
```
nvm --version
```
1. Instale la versión 16 más reciente de Node.js ejecutando **`nvm`**. (**`npm`** se incluye en Node.js).
```
nvm install v16
```
1. Confirme que Node.js está instalado ejecutando la versión de la línea de comandos de Node.js con la opción **`--version`**.
```
node --version
```
1. Confirme que **`npm`** está instalado mediante la ejecución de **`npm`** con la opción **`--version`**.
```
npm --version
```
1. Instálelo TypeScript **`npm`**ejecutándolo con la **`-g`**opción. Se instala TypeScript como un paquete global en el entorno.
```
npm install -g typescript
```
1. Confirme que TypeScript está instalado ejecutando el TypeScript compilador de línea de comandos con la **`--version`**opción.
```
tsc --version
```
## Paso 2: Agregar el código
1. En el AWS Cloud9 IDE, cree un archivo con el nombre`hello.ts`. (Para crear un archivo, en la barra de menús, elija **File** [Archivo], **New File** [Archivo nuevo]. Para guardar el archivo, elija **File** [Archivo], **Save** [Guardar]).
1. En un terminal del IDE, desde el mismo directorio que el archivo `hello.ts`, ejecute ** `npm` ** para instalar la biblioteca `@types/node`.
```
npm install @types/node
```
De este modo se añade una carpeta `node_modules/@types/node` en el mismo directorio que el archivo `hello.ts`. Esta nueva carpeta contiene las definiciones del tipo Node.js TypeScript que se necesitarán más adelante en este procedimiento para las `console.log` `process.argv` propiedades que va a añadir al `hello.ts` archivo.
1. Añada el siguiente código al archivo `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 + '.');
```
## Paso 3: Ejecutar el código
1. En la terminal, desde el mismo directorio que el `hello.ts` archivo, ejecute el TypeScript compilador. Especifique el archivo `hello.ts` y las bibliotecas adicionales que se incluirán.
```
tsc hello.ts --lib es6
```
TypeScript usa el `hello.ts` archivo y un conjunto de ECMAScript 6 (ES6) archivos de biblioteca para transpilar el TypeScript código del `hello.ts` archivo en un JavaScript código equivalente en un archivo denominado. `hello.js`
1. En la ventana **Environment (Entorno)**, abra el archivo `hello.js`.
1. En la barra de menú, elija **Run** (Ejecutar), **Run Configurations** (Configuraciones de ejecución), **New Run Configuration** (Nueva configuración de ejecución).
1. En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **Node.js**.
1. En **Command (Comando)**, escriba `hello.js 5 9`. En el código, `5` representa `process.argv[2]` y `9` representa `process.argv[3]`. (`process.argv[0]` representa el nombre del tiempo de ejecución (`node`) y `process.argv[1]` representa el nombre del archivo (`hello.js`)).
1. Elija **Run (Ejecutar)** y compare los resultados. Cuando haya terminado, elija **Stop (Detener)**.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Resultado de Node.js después de ejecutar el código en el IDE AWS Cloud9\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**nota**
En lugar de crear una nueva configuración de ejecución en el IDE, también puede ejecutar este código si ejecuta el comando ** `node hello.js 5 9` ** desde el terminal.
## Paso 4: Instalar y configurar el AWS SDK para JavaScript Node.js
Puede mejorar este ejemplo para usar el AWS SDK de Node.js para JavaScript crear un bucket de Amazon S3, enumerar los buckets disponibles y, a continuación, eliminar el bucket que acaba de crear.
En este paso, debe instalar y configurar el AWS SDK para JavaScript Node.js. El SDK proporciona una forma cómoda de interactuar con AWS servicios como Amazon S3 desde el JavaScript código. Tras instalar el AWS SDK JavaScript en Node.js, debe configurar la administración de credenciales en su entorno. El SDK necesita estas credenciales para interactuar con AWS los servicios.
### Para instalar el AWS SDK JavaScript en Node.js
En una sesión de terminal en el AWS Cloud9 IDE, desde el mismo directorio del que `hello.js` proviene el archivo[Paso 3: Ejecutar el código](#sample-typescript-run), ejecute **`npm`**para instalar el AWS SDK JavaScript en Node.js.
```
npm install aws-sdk
```
Este comando agrega varias carpetas a la carpeta `node_modules` del [Paso 3: Ejecutar el código](#sample-typescript-run). Estas carpetas contienen el código fuente y las dependencias del AWS SDK JavaScript de Node.js. Para obtener más información, consulte [Instalación del SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) en la *Guía para AWS SDK para JavaScript desarrolladores*.
### Para configurar la administración de credenciales en el entorno
Cada vez que utilices el AWS SDK JavaScript de Node.js para llamar a un AWS servicio, debes proporcionar un conjunto de credenciales con la llamada. Estas credenciales determinan si el AWS SDK JavaScript de Node.js tiene los permisos adecuados para realizar esa llamada. Si las credenciales no cubren los permisos adecuados, la llamada no se realizará correctamente.
En este paso, se almacenan las credenciales dentro del entorno. Para ello, siga las instrucciones de [Llamar Servicios de AWS desde un entorno de AWS Cloud9](credentials.md) y, a continuación, vuelva a este tema.
Para obtener información adicional, consulte [Configuración de credenciales en Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html) en la *Guía para desarrolladores de AWS SDK para JavaScript *.
## Paso 5: Agrega el código AWS del SDK
En este paso, agregará algo más de código, esta vez para interactuar con Amazon S3 y crear un bucket, ver una lista de los buckets disponibles y después eliminar el bucket que acaba de crear. Ejecutará este código más adelante.
1. En el AWS Cloud9 IDE, en el mismo directorio que el `hello.js` archivo de los pasos anteriores, cree un archivo con el nombre`s3.ts`.
1. Desde un terminal del AWS Cloud9 IDE, en el mismo directorio que el `s3.ts` archivo, habilite el código para llamar a las operaciones de Amazon S3 de forma asíncrona ejecutándolo **`npm`**dos veces para instalar la biblioteca asíncrona y otra vez para. TypeScript JavaScript
```
npm install @types/async # For TypeScript.
npm install async # For JavaScript.
```
1. Añada el siguiente código al archivo `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
]);
```
## Paso 6: ejecuta el código del SDK AWS
1. En la terminal, desde el mismo directorio que el `s3.ts` archivo, ejecuta el TypeScript compilador. Especifique el archivo `s3.ts` y las bibliotecas adicionales que se incluirán.
```
tsc s3.ts --lib es6
```
TypeScript usa el `s3.ts` archivo, el AWS SDK para JavaScript Node.js, la biblioteca asíncrona y un conjunto de ECMAScript 6 (ES6) archivos de biblioteca para transpilar el TypeScript código del archivo en JavaScript código equivalente en un `s3.ts` archivo denominado. `s3.js`
1. En la ventana **Environment (Entorno)**, abra el archivo `s3.js`.
1. En la barra de menú, elija **Run** (Ejecutar), **Run Configurations** (Configuraciones de ejecución), **New Run Configuration** (Nueva configuración de ejecución).
1. En la pestaña **[New] - Idle (Nuevo - Inactivo)**, elija **Runner: Auto (Ejecutor: automático)** y, a continuación, elija **Node.js**.
1. En **Command**, escriba`s3.js YOUR_BUCKET_NAME THE_AWS_REGION `, where ` YOUR_BUCKET_NAME ` es el nombre del bucket que desea crear y, a continuación, eliminar, y ` THE_AWS_REGION ` es el ID de la AWS región en la que se va a crear el bucket. Por ejemplo, para la región EE.UU. Este (Ohio), utilice `us-east-2`. Para obtener más información IDs, consulte [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) en. *Referencia general de Amazon Web Services*
**nota**
Los nombres de los buckets de Amazon S3 deben ser únicos en todas AWS las AWS cuentas, no solo en ellas.
1. Elija **Run (Ejecutar)** y compare los resultados. Cuando haya terminado, elija **Stop (Detener)**.
```
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:
```
## Paso 7: limpiar
Para evitar que se hagan cargos continuos a tu AWS cuenta una vez que hayas terminado de usar este ejemplo, debes eliminar el entorno. Para obtener instrucciones, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
# Tutorial de Docker para AWS Cloud9
En este tutorial, se muestra cómo conectar un entorno de desarrollo AWS Cloud9 SSH a un contenedor Docker en ejecución dentro de una instancia de Amazon Linux en Amazon EC2. Esto le permite usar el AWS Cloud9 IDE para trabajar con código y archivos dentro de un contenedor de Docker y ejecutar comandos en ese contenedor. Para obtener información acerca de Docker, consulte [Qué es Docker](https://www.docker.com/what-docker) en el sitio web de Docker.
Si sigue este tutorial y crea este ejemplo, es posible que se le cobren cargos a su AWS cuenta. Entre ellos, se incluyen posibles cargos por servicios como Amazon EC2. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Requisitos previos](#sample-docker-prereqs)
+ [Paso 1: instalar y ejecutar Docker](#sample-docker-install)
+ [Paso 2: Crear la imagen](#sample-docker-build)
+ [Paso 3: Ejecutar el contenedor](#sample-docker-run)
+ [Paso 4: Crear el entorno](#sample-docker-env)
+ [Paso 5: Ejecutar el código](#sample-docker-code)
+ [Paso 6: limpiar](#sample-docker-clean-up)
## Requisitos previos
+ **Debe tener una instancia de Amazon EC2 que ejecute Amazon Linux o Ubuntu Server.** En este ejemplo se supone que ya tiene una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server en su AWS cuenta. Para lanzar una instancia de Amazon EC2, consulte [Lanzar una máquina virtual Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/). En la página de **elección de una instancia de Amazon Machine Image (AMI)** del asistente, elija una AMI cuyo nombre para mostrar comience por **Amazon Linux AMI** o **Ubuntu Server**.
+ **Si la instancia Amazon EC2 se ejecuta en Amazon VPC, hay requisitos adicionales.** Consulte [Configuración de VPC para entornos de desarrollo AWS Cloud9](vpc-settings.md).
+ **La instancia Amazon EC2 debe tener al menos de 8 a 16 GB de espacio libre en disco.** Esta muestra utiliza imágenes de Docker de un tamaño superior a 3 GB y puede utilizar incrementos adicionales de 3 GB o más de espacio en disco para crear imágenes. Si intenta ejecutar esta muestra en un disco que tenga menos de 8 GB de espacio libre, es posible que la imagen de Docker no se cree o que el contenedor Docker no se ejecute. Para consultar el espacio libre en el disco de la instancia, puede ejecutar un comando como ** `df -h` ** (para "información del sistema de archivos del disco en formato legible") en la instancia. Para aumentar el tamaño del disco de una instancia existente, consulte [Modifying a Volume](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html) en la *Guía del usuario de Amazon EC2*.
## Paso 1: instalar y ejecutar Docker
En este paso, verificará si Docker está instalado en la instancia de Amazon EC2 y, si no es así, lo instalará. Después de instalar Docker, ejecútelo en la instancia.
1. Conéctese a la instancia de Amazon EC2 en ejecución mediante un cliente SSH como la utilidad ** `ssh` ** o PuTTY. Para ello, consulte "Paso 3: conectarse a la instancia" en [Lanzar una máquina virtual Linux](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/).
1. Compruebe si Docker está instalado en la instancia. Para ello, ejecute el comando ** `docker` ** en la instancia con la opción ** `--version` **.
```
docker --version
```
Si Docker está instalado, se muestran la versión y el número de compilación de Docker. En este caso, vaya al paso 5 más adelante de este procedimiento.
1. Instale Docker. Para ello, ejecute el comando **`yum`** o **`apt`** con la acción **`install`** y especifique el paquete **`docker`** o **`docker.io`** que se va a instalar.
Para Amazon Linux:
```
sudo yum install -y docker
```
Para Ubuntu Server:
```
sudo apt install -y docker.io
```
1. Confirme que Docker está instalado. Para ello, vuelva a ejecutar el comando ** `docker --version` **. Se muestran la versión y el número de compilación de Docker.
1. Ejecute Docker. Para ello, ejecute el comando **`service`** con el servicio **`docker`** y la acción **`start`**.
```
sudo service docker start
```
1. Confirme que Docker se está ejecutando. Para ello, ejecute el comando ** `docker` ** con la acción ** `info` **.
```
sudo docker info
```
Si se está ejecutando, se muestra información sobre Docker.
## Paso 2: Crear la imagen
En este paso, se utiliza un Dockerfile para crear una imagen de Docker para en la instancia. Esta muestra utiliza una imagen que incluye Node.js y una aplicación de servidor de chat de muestra.
1. En la instancia, cree el Dockerfile. Para ello, con el cliente SSH todavía conectado a la instancia, en el directorio `/tmp` de la instancia, cree un archivo llamado `Dockerfile`. Por ejemplo, ejecute el comando ** `touch` ** del modo siguiente.
```
sudo touch /tmp/Dockerfile
```
1. Añada el siguiente contenido al archivo `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 añadir el contenido anterior al archivo `Dockerfile`, puede utilizar la utilidad ** `vi` ** en la instancia tal y como se indica a continuación.
1. Use el AWS Cloud9 para abrir y editar el `/tmp/Dockerfile` archivo.
```
sudo vi /tmp/Dockerfile
```
1. Pegue el contenido anterior en el archivo `Dockerfile`. Si no sabe cómo hacerlo, consulte la documentación de su cliente SSH.
1. Cambie al modo de comando. Para ello, pulse la tecla `Esc`. (`-- INSERT --` desaparece de la parte inferior de la ventana).
1. Escriba `:wq` (para escribir en el archivo `/tmp/Dockerfile`, guárdelo y, a continuación, salga de ** `vi` **) y, a continuación, pulse `Enter`.
**nota**
Puede acceder a una lista de imágenes de Docker que se actualiza con frecuencia desde AWS CodeBuild. Para obtener más información, consulte [las imágenes de Docker que se proporcionan CodeBuild en la](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html) Guía del *AWS CodeBuild usuario*.
1. En la instancia, crea un archivo que contenga la clave pública AWS Cloud9 SSH para que la utilice el contenedor de Docker. Para ello, en el mismo directorio que el archivo `Dockerfile`, cree un archivo llamado `authorized_keys`, por ejemplo, ejecutando el comando ** `touch` **.
```
sudo touch /tmp/authorized_keys
```
1. Agrega la clave pública AWS Cloud9 SSH al archivo. `authorized_keys` Para obtener la clave pública AWS Cloud9 SSH, haga lo siguiente:
1. Abre la AWS Cloud9 consola en. [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/)
1. En la barra de AWS navegación, en el selector de AWS regiones, elija la AWS región en la que desee crear el entorno de AWS Cloud9 desarrollo más adelante en este tema.
1. Si aparece una página de bienvenida, en **Nuevo AWS Cloud9 entorno**, elija **Crear entorno**. De lo contrario, elija **Create environment (Crear entorno)**.
1. En la página **Name environment** (Asignar nombre al entorno), en **Name** (Nombre), escriba un nombre para el entorno. (El nombre no es importante aquí. Elegirá uno diferente más tarde).
1. Elija **Next Step** (Paso siguiente).
1. En **Environment type (Tipo de entorno)**, elija **Connect and run in remote server (SSH) (Conectar y ejecutar en un servidor remoto (SSH))**.
1. Expanda **View public SSH key (Ver clave SSH pública)**.
1. Elija **Copy key to clipboard (Copiar clave en portapapeles)**. (Está entre **View public SSH key (Ver clave pública SSH)** y **Advanced settings (Configuración avanzada)**.)
1. Elija **Cancelar**.
1. Pegue el contenido del portapapeles en el archivo `authorized_keys` y, a continuación, guárdelo. Por ejemplo, puede usar la utilidad ** `vi` **, como se ha descrito anteriormente en este paso.
1. Para crear la imagen, ejecute el comando **`docker`** con la acción **`build`**, agregue la etiqueta `cloud9-image:latest` a la imagen y especifique la ruta al archivo `Dockerfile` que se utilizará.
```
sudo docker build -t cloud9-image:latest /tmp
```
Si se realiza correctamente, las dos últimas líneas de la salida de compilación muestran `Successfully built` y `Successfully tagged`.
Para confirmar que Docker ha creado correctamente la imagen, ejecute el comando ** `docker` ** con la acción `image ls`.
```
sudo docker image ls
```
Si se realiza correctamente, la salida muestra una entrada en la que el campo `REPOSITORY` está configurado en `cloud9-image` y el campo `TAG` está configurado en `latest`.
1. Anote la dirección IP pública de la instancia de Amazon EC2. Lo necesitará para el [Paso 4: Crear el entorno](#sample-docker-env). Si no está seguro de cuál es la dirección IP pública de la instancia, puede ejecutar el siguiente comando en la instancia para obtenerla.
```
curl http://169.254.169.254/latest/meta-data/public-ipv4
```
## Paso 3: Ejecutar el contenedor
En este paso, ejecutará un contenedor Docker en la instancia. Este contenedor se basa en la imagen que creó en el paso anterior.
1. Para ejecutar el contenedor Docker, ejecute el comando ** `docker` ** en la instancia con la acción ** `run` ** y las siguientes opciones.
```
sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
```
+ `-d` ejecuta el contenedor en modo desasociado y sale siempre que el proceso raíz que se utiliza para ejecutar las salidas del contenedor (en esta muestra, el cliente SSH).
+ `-it` ejecuta el contenedor con un pseudoTTY asignado y mantiene STDIN abierto, incluso si el contenedor no está asociado.
+ `--expose` hace que el puerto especificado (en esta muestra, el puerto `9090`) esté disponible desde el contenedor.
+ `-p` hace que el puerto especificado esté disponible internamente para la instancia de Amazon EC2 a través de la dirección IP y el puerto especificados. En esta muestra, se puede acceder internamente al puerto `9090` del contenedor a través del puerto `22` de la instancia de Amazon EC2.
+ `--name` es un nombre en lenguaje natural para el contenedor (en esta muestra, `cloud9`).
+ `cloud9-image:latest` es el nombre en lenguaje natural de la imagen creada que se va a utilizar para ejecutar el contenedor.
Para confirmar que Docker está ejecutando correctamente el contenedor, ejecute el comando ** `docker` ** con la acción `container ls`.
```
sudo docker container ls
```
Si se realiza correctamente, la salida muestra una entrada en la que el campo `IMAGE` está configurado en `cloud9-image:latest` y el campo `NAMES` está configurado en `cloud9`.
1. Inicie sesión en el contenedor en ejecución. Para ello, ejecute el comando ** `docker` ** con la acción ** `exec` ** y las siguientes opciones.
```
sudo docker exec -it cloud9 bash
```
+ `-it` ejecuta el contenedor con un pseudoTTY asignado y mantiene STDIN abierto, incluso si el contenedor no está asociado.
+ `cloud9` es el nombre en lenguaje natural del contenedor en ejecución.
+ `bash` inicia el shell estándar en el contenedor en ejecución.
Si se realiza correctamente, el símbolo del terminal cambia para mostrar el nombre del usuario que ha iniciado sesión del contenedor y el ID del contenedor.
**nota**
Si desea salir del contenedor en ejecución, ejecute el comando ** `exit` **. El símbolo del terminal cambia vuelve a mostrar el nombre del usuario que ha iniciado sesión de la instancia y el DNS privado de la instancia. El contenedor debe seguir en ejecución.
1. Para el directorio del contenedor en ejecución desde el que desee AWS Cloud9 iniciar sesión, defina sus permisos de acceso en **`rwxr-xr-x`**. Esto significa read-write-execute permisos para el propietario, permisos de lectura y ejecución para el grupo y permisos de lectura y ejecución para otros. Por ejemplo, si la ruta del directorio es `~`, puede establecer estos permisos en el directorio ejecutando el comando ** `chmod` ** en el contenedor en ejecución del siguiente modo.
```
sudo chmod u=rwx,g=rx,o=rx ~
```
1. Anote la ruta al directorio en el contenedor en ejecución que contiene el binario Node.js, ya que lo necesitará para el [Paso 4: Crear el entorno](#sample-docker-env). Si no está seguro de cuál es esta ruta, ejecute el siguiente comando en el contenedor en ejecución para obtenerla.
```
which node
```
## Paso 4: Crear el entorno
En este paso, debe AWS Cloud9 crear un entorno de desarrollo AWS Cloud9 SSH y conectarlo al contenedor Docker en ejecución. Una AWS Cloud9 vez creado el entorno, muestra el AWS Cloud9 IDE para que puedas empezar a trabajar con los archivos y el código del contenedor.
Se crea un entorno de desarrollo AWS Cloud9 SSH con la AWS Cloud9 consola. No puede crear un entorno de SSH con la CLI.
### Requisitos previos
+ Asegúrese de completar los pasos de [Con AWS Cloud9 figuración](setting-up.md) en primer lugar. De esa forma, puede iniciar sesión en la consola de AWS Cloud9 y crear entornos.
+ Identifique una instancia de computación en la nube existente (por ejemplo, una instancia de Amazon EC2 en la suya Cuenta de AWS) o su propio servidor que desee conectar AWS Cloud9 al entorno.
+ Asegúrese de que la instancia existente o su propio servidor cumpla todos los [Requisitos del host SSH](ssh-settings.md#ssh-settings-requirements). Esto incluye tener versiones específicas de Python, Node.js y otros componentes instaladas, configurar permisos específicos en el directorio desde el que desea que se inicie AWS Cloud9 después del inicio de sesión y configurar cualquier instancia de Amazon Virtual Private Cloud asociada.
### Crear el entorno de SSH
1. Asegúrese de que ha completado los requisitos anteriores.
1. Si todavía no se ha conectado a su instancia existente o a su propio servidor, conéctese con un cliente SSH. De este modo, podrá agregar el valor de clave pública SSH necesario a la instancia o al servidor. Esto se describe más adelante en este procedimiento.
**nota**
Para conectarse a una instancia de Nube de AWS procesamiento existente, consulte uno o varios de los siguientes recursos:
En el caso de Amazon EC2, consulte [Connect to Your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) en la *Guía del usuario de Amazon EC2*.
Para Amazon Lightsail, consulte [Connect to your Linux/Unix-based Lightsail instance](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server) en la *documentación de Amazon Lightsail*.
Para ello AWS Elastic Beanstalk, consulte Cómo [enumerar las instancias de servidor y conectarse a](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.ec2connect.html) ellas en la *guía para AWS Elastic Beanstalk desarrolladores*.
Para AWS OpsWorks ello, consulte [Uso de SSH para iniciar sesión en una instancia de Linux](https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-ssh.html) en la *Guía del AWS OpsWorks usuario*.
Para otros Servicios de AWS, consulte la documentación de ese servicio específico.
Para conectarse a su propio servidor, utilice SSH. SSH ya está instalado en los sistemas operativos macOS y Linux. Para conectarse a su servidor mediante SSH en Windows, debe instalar [PuTTY](https://www.putty.org/).
1. Inicie sesión en la AWS Cloud9 consola, en [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).
1. Después de iniciar sesión en la AWS Cloud9 consola, en la barra de navegación superior, elige una en la Región de AWS que crear el entorno. Para ver una lista de los disponibles Regiones de AWS, consulte [AWS Cloud9](https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region)en *Referencia general de AWS*.
![\[Selector de regiones en la AWS Cloud9 consola\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/images/consolas_region_new_UX.png)
1. Si es la primera vez que crea un entorno de desarrollo, se muestra una página de bienvenida. En el panel **Nuevo AWS Cloud9 entorno**, selecciona **Crear entorno**.
Si ya ha creado entornos de desarrollo anteriormente, también puede expandir el panel de la izquierda de la pantalla. Elija **Your environments** (Sus entornos) y, a continuación, **Create environment** (Crear entorno).
En la página de **bienvenida**:
![\[Selección del botón Create environment (Crear entorno) si se muestra la página de bienvenida\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)
O bien, en la página **Your environments** (Sus entornos):
![\[Selección del botón Create environment (Crear entorno) si no se muestra la página de bienvenida\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/images/console_create_env_new_UX.png)
1. En la página **Create environment** (Crear entorno), ingrese un nombre para su entorno.
1. En **Description** (Descripción), ingrese una nota acerca de su entorno. Para este tutorial, utilice `This environment is for the AWS Cloud9 tutorial.`
1. En **Environment type** (Tipo de entorno), elija **Existing Compute** (Computación existente) en las opciones siguientes:
+ **Nueva instancia EC2: lanza una instancia** de Amazon EC2 a la AWS Cloud9 que se puede conectar directamente a través de SSH.
+ **Computación existente**: lanza una instancia de Amazon EC2 que no requiere ningún puerto de entrada abierto. AWS Cloud9 se conecta a la instancia a través de. [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html)
+ Si selecciona la opción **Existing compute** (Computación existente), se crean un rol de servicio y un perfil de instancia de IAM para permitir que Systems Manager interactúe con la instancia de EC2 en su nombre. Puede ver los nombres de ambos en la sección **Service role and instance profile for Systems Manager access** (Función de servicio y perfil de instancias para el acceso a Systems Manager) más abajo en la interfaz. Para obtener más información, consulte [Acceso a instancias EC2 sin entrada con AWS Systems Manager](ec2-ssm.md).
**aviso**
La creación de una instancia EC2 para su entorno podría implicar posibles cargos Cuenta de AWS para Amazon EC2. No hay costo adicional por el uso de Systems Manager para administrar las conexiones a la instancia de EC2.
**aviso**
AWS Cloud9 utiliza una clave pública SSH para conectarse de forma segura a su servidor. Para establecer la conexión segura, agregue nuestra clave pública a su archivo `~/.ssh/authorized_keys` y facilite sus credenciales de acceso en los pasos siguientes. Elija **Copy key to clipboard** (Copiar clave en el portapapeles) para copiar la clave SSH o **View public SSH key** (Ver clave SSH pública) para mostrarla.
1. En el panel **Existing compute** (Computación existente), en **User** (Usuario), ingrese el nombre de usuario que utilizó para conectarse a la instancia o al servidor anteriormente en este procedimiento. Por ejemplo, en el caso de una instancia de computación en la Nube de AWS , podría ser `ec2-user`, `ubuntu` o `root`.
**nota**
Recomendamos que el nombre de inicio de sesión esté asociado a los permisos de administrador o a un usuario administrador en la instancia o el servidor. Más concretamente, recomendamos que este nombre de usuario sea el propietario de la instalación de Node.js en la instancia o el servidor. Para verificarlo, ejecute el comando **`ls -l $(which node)`** desde el terminal de la instancia o el servidor (o **`ls -l $(nvm which node)` ** si utiliza `nvm`). Este comando muestra el nombre del propietario de la instalación de Node.js. También muestra los permisos de la instalación, el nombre del grupo y la ubicación.
1. En **Host**, ingrese la dirección IP pública (preferida) o el nombre de host de la instancia o el servidor.
1. En **Puerto**, introduce el puerto que quieres usar AWS Cloud9 para intentar conectarte a la instancia o al servidor. También puede mantener el puerto predeterminado.
1. Elija **Additional details - optional** (Detalles adicionales [opcional]) para mostrar la ruta de entorno, la ruta al binario de node.js y la información del host de salto de SSH.
1. En **Ruta del entorno**, introduce la ruta al directorio de la instancia o el servidor desde el que AWS Cloud9 quieres empezar. Lo identificó anteriormente en los requisitos previos de este procedimiento. Si deja este campo en blanco, AWS Cloud9 utiliza el directorio que su instancia o servidor utiliza normalmente para comenzar después de iniciar sesión. Normalmente, es un directorio raíz o predeterminado.
1. En **Path to Node.js binary path** (Ruta al binario de Node.js), ingrese la información de la ruta para especificar la ruta al binario de Node.js en la instancia o el servidor. Para obtener la ruta, puede ejecutar el comando **`which node`** (o **`nvm which node`** si está utilizando `nvm`) en su instancia o servidor. Por ejemplo, la ruta puede ser `/usr/bin/node`. Si deja este campo en blanco, AWS Cloud9 intenta adivinar dónde se encuentra el archivo binario Node.js cuando intenta conectarse.
1. En **SSH jump host** (Host de salto de SSH), ingrese información sobre el host de salto que utiliza la instancia o el servidor. Utilice el formato `USER_NAME@HOSTNAME:PORT_NUMBER` (por ejemplo, `ec2-user@:ip-192-0-2-0:22`).
El host de salto debe cumplir los siguientes requisitos:
+ Debe ser accesible a través de la red de internet pública utilizando SSH.
+ Debe permitir el acceso de entrada desde cualquier dirección IP a través del puerto especificado.
+ El valor de clave pública de SSH que se ha copiado en el archivo `~/.ssh/authorized_keys` que se encuentra en el servidor o instancia existente también se debe copiar en el archivo `~/.ssh/authorized_keys` que se encuentra en el host de salto.
+ Netcat debe estar instalado.
1. Añada hasta 50 etiquetas suministrando los valores de **Key (Clave)** y **Value (Valor)** para cada etiqueta. Para ello, seleccione **Add new tag** (Agregar nueva etiqueta). Las etiquetas se adjuntan al AWS Cloud9 entorno como etiquetas de recursos y se propagan a los siguientes recursos subyacentes: la CloudFormation pila, la instancia de Amazon EC2 y los grupos de seguridad de Amazon EC2. Para obtener más información sobre las etiquetas, consulte [Control del acceso mediante etiquetas de AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) en la *[Guía del usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/)* y la [información avanzada](tags.md) sobre las etiquetas en esta guía.
**aviso**
Si actualiza estas etiquetas después de crearlas, los cambios no se propagan a los recursos subyacentes. Para obtener más información, consulte [Propagación de actualizaciones de etiquetas a los recursos subyacentes](tags.md#tags-propagate) en la información avanzada acerca de las [etiquetas](tags.md).
1. Elija **Create** (Crear) para crear su entorno y se le redirigirá a la página de inicio. Cuando la cuenta se haya creado correctamente, aparecerá una barra flash verde en la parte superior de la AWS Cloud9 consola. Puede seleccionar el nuevo entorno y elegir **Open in Cloud9** (Abrir en Cloud9) para lanzar el IDE.
![\[AWS Cloud9 Selector IDE en la AWS Cloud9 consola\]](http://docs.aws.amazon.com/es_es/cloud9/latest/user-guide/images/cloud9-ide-open.png)
Si se produce un error al crear la cuenta, aparecerá una barra parpadeante roja en la parte superior de la consola de AWS Cloud9 . Es posible que la cuenta no se pueda crear debido a un problema con el navegador web, los permisos de AWS acceso, la instancia o la red asociada. Puede encontrar información sobre posibles soluciones a los problemas que pueden provocar el error de la cuenta en la [sección Solución de problemas de AWS Cloud9](troubleshooting.md#troubleshooting-env-loading).
**nota**
Si su entorno utiliza un proxy para acceder a Internet, debe proporcionar los detalles del proxy para AWS Cloud9 que pueda instalar las dependencias. Para obtener más información, consulte [Fallo al instalar dependencias](troubleshooting.md#proxy-failed-dependencies).
## Paso 5: Ejecutar el código
En este paso, utilizará el AWS Cloud9 IDE para ejecutar una aplicación de muestra dentro del contenedor Docker en ejecución.
1. Con el AWS Cloud9 IDE mostrado para el contenedor en ejecución, inicie el servidor de chat de muestra. Para ello, en la ventana **Environment (Entorno)**, haga clic con el botón derecho en el archivo `workspace/server.js` de muestra y, a continuación, seleccione **Run (Ejecutar)**.
1. Obtenga una vista previa de la aplicación de muestra. Para ello, en la ventana **Environment (Entorno)**, abra el archivo `workspace/client/index.html`. A continuación, en la barra de menús, seleccione **Tools, Preview, Preview Running Application (Herramientas, Vista previa, Vista previa de la aplicación en ejecución)**.
1. En la pestaña de vista previa de la aplicación, en **Your Name (Su nombre)**, escriba su nombre. En **Message (Mensaje)** escriba un mensaje. A continuación, elija **Send (Enviar)**. El servidor de chat añade su nombre y su mensaje a la lista.
## Paso 6: limpiar
En este paso, se elimina el entorno y se eliminan AWS Cloud9 los archivos de soporte de Docker de la instancia de Amazon EC2. Además, para evitar que se sigan realizando cargos en su AWS cuenta una vez que haya terminado de usar este ejemplo, debe cerrar la instancia de Amazon EC2 que ejecuta Docker.
### Paso 6.1: Eliminar el entorno
Para eliminar el entorno, consulte [Eliminar un entorno en AWS Cloud9](delete-environment.md).
### Paso 6.2: Eliminar los archivos AWS Cloud9 de soporte del contenedor
Tras eliminar el entorno, algunos archivos de AWS Cloud9 soporte permanecerán en el contenedor. Si desea seguir utilizando el contenedor pero ya no necesita estos archivos de soporte, elimine la `.c9` carpeta del directorio del contenedor desde el que especificó AWS Cloud9 empezar después de iniciar sesión. Por ejemplo, si el directorio es `~`, ejecute el comando **`rm`** con la opción **`-r`**, tal y como se indica a continuación.
```
sudo rm -r ~/.c9
```
### Paso 6.3: Eliminar los archivos de soporte de Docker de la instancia
Si ya no desea conservar el contenedor de Docker, la imagen de Docker y Docker en la instancia de Amazon EC2, pero desea conservar la instancia, puede eliminar estos archivos de soporte de Docker de la siguiente manera.
1. Elimine el contenedor Docker de la instancia. Para ello, ejecute el comando **`docker`** en la instancia con las acciones de detención **`stop`** y **`rm`**, y el nombre en lenguaje natural del contenedor.
```
sudo docker stop cloud9
sudo docker rm cloud9
```
1. Elimine la imagen de Docker de la instancia. Para ello, ejecute el comando ** `docker` ** en la instancia con la acción ** `image rm` ** y la etiqueta de la imagen.
```
sudo docker image rm cloud9-image:latest
```
1. Elimine los archivos de soporte de Docker adicionales que aún puedan quedar. Para ello, ejecute el comando ** `docker` ** en la instancia con la acción ** `system prune` **.
```
sudo docker system prune -a
```
1. Desinstale Docker. Para ello, ejecute el comando **`yum`** en la instancia con la acción **`remove`** y especifique el paquete **`docker`** que se va a desinstalar.
Para Amazon Linux:
```
sudo yum -y remove docker
```
Para Ubuntu Server:
```
sudo apt -y remove docker
```
También puede eliminar los archivos `Dockerfile` y `authorized_keys` que creó anteriormente. Por ejemplo, ejecute el siguiente comando ** `rm` ** en la instancia.
```
sudo rm /tmp/Dockerfile
sudo rm /tmp/authorized_keys
```
### Paso 6.4: Terminar la instancia
Para terminar la instancia de Amazon EC2, consulte [Terminate Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) en la *Guía del usuario de Amazon EC2*.
## Tutoriales relacionados
+ [Cómo empezar AWS RoboMaker](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html) en la *Guía para AWS RoboMaker desarrolladores*. Este tutorial se utiliza AWS Cloud9 para modificar, crear y empaquetar una aplicación de robot de muestra.