

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.

# Trabajar con revisiones de aplicaciones para CodeDeploy
<a name="application-revisions"></a>

En CodeDeploy, una revisión contiene una versión de los archivos fuente que CodeDeploy se implementarán en las instancias o los scripts CodeDeploy se ejecutarán en las instancias. 

Planifica la revisión, añade un AppSpec archivo a la revisión y, a continuación, envía la revisión a Amazon S3 o GitHub. Una vez enviada la revisión, puede implementarla.

**Topics**
+ [Planificación de una revisión](application-revisions-plan.md)
+ [Añadir un AppSpec archivo](application-revisions-appspec-file.md)
+ [Elección de un tipo de repositorio](application-revisions-repository-type.md)
+ [Envío de una revisión](application-revisions-push.md)
+ [Visualización de los detalles de una revisión de aplicación](application-revisions-view-details.md)
+ [Registro de una revisión de una aplicación](application-revisions-register.md)

# Planificación de una revisión de CodeDeploy
<a name="application-revisions-plan"></a>

Con unos buenos planes es mucho más fácil implementar las revisiones.

Para las implementaciones en una plataforma de informática de AWS Lambda o Amazon ECS, una revisión es lo mismo que el archivo AppSpec. La siguiente información no es aplicable. Para obtener más información, consulte [Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md) 

Para las implementaciones en una plataforma de informática EC2/en las instalaciones, comience por crear un directorio raíz (carpeta) vacío en la máquina de desarrollo. Ahí es donde almacenará los archivos de código fuente (como los archivos de texto y binarios, los ejecutables, los paquetes, etc.) que se van a implementan en las instancias o los scripts que se van a ejecutar en las instancias.

Por ejemplo, en la carpeta raíz `/tmp/` en Linux, macOS o Unix o en la carpeta raíz `c:\temp` en Windows:

```
/tmp/ or c:\temp (root folder)
  |--content (subfolder)
  |    |--myTextFile.txt
  |    |--mySourceFile.rb
  |    |--myExecutableFile.exe
  |    |--myInstallerFile.msi
  |    |--myPackage.rpm
  |    |--myImageFile.png
  |--scripts (subfolder)
  |    |--myShellScript.sh
  |    |--myBatchScript.bat 
  |    |--myPowerShellScript.ps1 
  |--appspec.yml
```

La carpeta raíz también debe incluir también un archivo de especificación de aplicación (archivo AppSpec), tal y como se muestra aquí. Para obtener más información, consulte [Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md).

# Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy
<a name="application-revisions-appspec-file"></a>

En este tema se muestra cómo añadir un AppSpec archivo a la implementación. También incluye plantillas para crear un AppSpec archivo para una implementación de AWS Lambda y EC2/on-premise.

**Topics**
+ [Añadir un AppSpec archivo para una implementación de Amazon ECS](#add-appspec-file-ecs)
+ [Agregar un AppSpec archivo para una implementación de AWS Lambda](#add-appspec-file-lambda)
+ [Agregue un AppSpec archivo para una implementación local de EC2/](#add-appspec-file-server)

## Añadir un AppSpec archivo para una implementación de Amazon ECS
<a name="add-appspec-file-ecs"></a>

Para una implementación en una plataforma de informática de Amazon ECS:
+ El AppSpec archivo especifica la definición de tareas de Amazon ECS utilizada para la implementación, el nombre del contenedor y la asignación de puertos que se utilizan para enrutar el tráfico, y las funciones Lambda opcionales que se ejecutan después de los eventos del ciclo de vida de la implementación.
+ Una revisión es lo mismo que un AppSpec archivo.
+ Un AppSpec archivo se puede escribir con JSON o YAML.
+ Un AppSpec archivo puede guardarse como archivo de texto o introducirse directamente en una consola al crear una implementación. Para obtener más información, consulte [Creación de una implementación en una plataforma de informática de Amazon ECS (consola)](deployments-create-console-ecs.md).

**Para crear un AppSpec archivo**

1. Copia la plantilla JSON o YAML en un editor de texto o en el AppSpec editor de la consola.

1. Modifique la plantilla como sea necesario.

1. Usa un validador de JSON o YAML para validar tu archivo. AppSpec **Si utilizas el AppSpec editor, el archivo se valida al elegir Crear despliegue.**

1. Si utiliza un editor de texto, guarde el archivo. Si utilizas el AWS CLI para crear tu implementación, consulta el AppSpec archivo si está en tu disco duro o en un bucket de Amazon S3. Si usa la consola, debe enviar el AppSpec archivo a Amazon S3.

### Plantilla de AppSpec archivo YAML para una implementación de Amazon ECS con instrucciones
<a name="app-spec-template-yaml-ecs"></a>

La siguiente es una plantilla YAML de un AppSpec archivo para una implementación de Amazon ECS con todas las opciones disponibles. Para obtener más información acerca de los eventos del ciclo de vida que se deben utilizar en la sección `hooks`, consulte [AppSpec sección «ganchos» para una implementación de Amazon ECS](reference-appspec-file-structure-hooks.md#appspec-hooks-ecs).

```
# This is an appspec.yml template file for use with an Amazon ECS deployment in CodeDeploy.
# The lines in this template that start with the hashtag are 
#   comments that can be safely left in the file or 
#   ignored.
# For help completing this file, see the "AppSpec File Reference" in the  
#   "CodeDeploy User Guide" at
#   https://docs.aws.amazon.com/codedeploy/latest/userguide/app-spec-ref.html
version: 0.0
# In the Resources section, you must specify the following: the Amazon ECS service, task definition name, 
# and the name and port of the load balancer to route traffic,
# target version, and (optional) the current version of your AWS Lambda function. 
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: "" # Specify the ARN of your task definition (arn:aws:ecs:region:account-id:task-definition/task-definition-family-name:task-definition-revision-number)
        LoadBalancerInfo: 
          ContainerName: "" # Specify the name of your Amazon ECS application's container
          ContainerPort: "" # Specify the port for your container where traffic reroutes 
# Optional properties
        PlatformVersion: "" # Specify the version of your Amazon ECS Service
        NetworkConfiguration:
          AwsvpcConfiguration:
            Subnets: ["",""] # Specify one or more comma-separated subnets in your Amazon ECS service
            SecurityGroups: ["",""] # Specify one or more comma-separated security groups in your Amazon ECS service
            AssignPublicIp: "" # Specify "ENABLED" or "DISABLED"             
# (Optional) In the Hooks section, specify a validation Lambda function to run during 
# a lifecycle event. 
Hooks:
# Hooks for Amazon ECS deployments are:
    - BeforeInstall: "" # Specify a Lambda function name or ARN
    - AfterInstall: "" # Specify a Lambda function name or ARN
    - AfterAllowTestTraffic: "" # Specify a Lambda function name or ARN
    - BeforeAllowTraffic: "" # Specify a Lambda function name or ARN
    - AfterAllowTraffic: "" # Specify a Lambda function name or ARN
```

### AppSpec Archivo JSON para una plantilla de despliegue de Amazon ECS
<a name="app-spec-template-json-ecs"></a>

La siguiente es una plantilla JSON para un AppSpec archivo para una implementación de Amazon ECS con todas las opciones disponibles. Para ver las instrucciones de plantilla, consulte los comentarios de la versión YAML en la sección anterior. Para obtener más información acerca de los eventos del ciclo de vida que se deben utilizar en la sección `hooks`, consulte [AppSpec sección «ganchos» para una implementación de Amazon ECS](reference-appspec-file-structure-hooks.md#appspec-hooks-ecs).

```
{
	"version": 0.0,
	"Resources": [
		{
			"TargetService": {
				"Type": "AWS::ECS::Service",
				"Properties": {
    			"TaskDefinition": "",
    			"LoadBalancerInfo": {
    				"ContainerName": "",
    				"ContainerPort":
    			},
    			"PlatformVersion": "",
    			"NetworkConfiguration": {
    				"AwsvpcConfiguration": {
    					"Subnets": [
    						"",
    						""
    					],
    					"SecurityGroups": [
    						"",
    						""
    					],
    					"AssignPublicIp": ""
    				}
    			}
  			}				
			}
		}
	],
	"Hooks": [
		{
			"BeforeInstall": ""
		},
		{
			"AfterInstall": ""
		},
		{
			"AfterAllowTestTraffic": ""
		},
		{
			"BeforeAllowTraffic": ""
		},
		{
			"AfterAllowTraffic": ""
		}
	]
}
```

## Agregar un AppSpec archivo para una implementación de AWS Lambda
<a name="add-appspec-file-lambda"></a>

Para una implementación en una plataforma de procesamiento AWS Lambda:
+ El AppSpec archivo contiene instrucciones sobre las funciones Lambda que se van a implementar y utilizar para la validación de la implementación.
+ Una revisión es lo mismo que un AppSpec archivo.
+ Un AppSpec archivo se puede escribir con JSON o YAML.
+ Un AppSpec archivo puede guardarse como archivo de texto o introducirse directamente en un AppSpec editor de consola al crear una implementación. Para obtener más información, consulte [Crear una implementación de AWS Lambda Compute Platform (consola)](deployments-create-console-lambda.md).

Para crear un AppSpec archivo:

1. Copia la plantilla JSON o YAML en un editor de texto o en el AppSpec editor de la consola.

1. Modifique la plantilla como sea necesario.

1. Usa un validador de JSON o YAML para validar tu archivo. AppSpec **Si utilizas el AppSpec editor, el archivo se valida al elegir Crear despliegue.**

1. Si utiliza un editor de texto, guarde el archivo. Si utilizas el AWS CLI para crear tu implementación, consulta el AppSpec archivo si está en tu disco duro o en un bucket de Amazon S3. Si usa la consola, debe enviar el AppSpec archivo a Amazon S3.



### Plantilla de AppSpec archivo YAML para una AWS Lambda implementación con instrucciones
<a name="app-spec-template-yaml-lambda"></a>

Para obtener más información acerca de los eventos del ciclo de vida que se deben utilizar en la sección de enlaces, consulte [AppSpec sección de «ganchos» para una implementación de AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda).

```
# This is an appspec.yml template file for use with an AWS Lambda deployment in CodeDeploy.
# The lines in this template starting with the hashtag symbol are 
#   instructional comments and can be safely left in the file or 
#   ignored.
# For help completing this file, see the "AppSpec File Reference" in the  
#   "CodeDeploy User Guide" at
#   https://docs.aws.amazon.com/codedeploy/latest/userguide/app-spec-ref.html
version: 0.0
# In the Resources section specify the name, alias, 
# target version, and (optional) the current version of your AWS Lambda function. 
Resources:
  - MyFunction: # Replace "MyFunction" with the name of your Lambda function 
      Type: AWS::Lambda::Function
      Properties:
        Name: "" # Specify the name of your Lambda function
        Alias: "" # Specify the alias for your Lambda function
        CurrentVersion: "" # Specify the current version of your Lambda function
        TargetVersion: "" # Specify the version of your Lambda function to deploy
# (Optional) In the Hooks section, specify a validation Lambda function to run during 
# a lifecycle event. Replace "LifeCycleEvent" with BeforeAllowTraffic
# or AfterAllowTraffic. 
Hooks:
    - LifeCycleEvent: "" # Specify a Lambda validation function between double-quotes.
```

### AppSpec Archivo JSON para una plantilla de AWS Lambda despliegue
<a name="app-spec-template-json-lambda"></a>

En la siguiente plantilla, sustituya MyFunction "» por el nombre de la AWS Lambda función. En la sección Hooks opcional, sustituye los eventos del ciclo de vida por BeforeAllowTraffic o AfterAllowTraffic.

Para obtener más información acerca de los eventos del ciclo de vida que se deben utilizar en la sección Hooks, consulte [AppSpec sección de «ganchos» para una implementación de AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda).

```
{
 	"version": 0.0,
 	"Resources": [{
 		"MyFunction": {
 			"Type": "AWS::Lambda::Function",
 			"Properties": {
 				"Name": "",
 				"Alias": "",
 				"CurrentVersion": "",
 				"TargetVersion": ""
 			}
 		}
 	}],
 	"Hooks": [{
 			"LifeCycleEvent": ""
 		}
 	]
 }
```

## Agregue un AppSpec archivo para una implementación local de EC2/
<a name="add-appspec-file-server"></a>

Sin un AppSpec archivo, CodeDeploy no puede asignar los archivos de origen de la revisión de la aplicación a sus destinos ni ejecutar scripts para su implementación en una plataforma informática local de EC2/.

Cada revisión debe contener solo un archivo. AppSpec 

Para añadir un AppSpec archivo a una revisión:

1. Copie la plantilla en un editor de texto.

1. Modifique la plantilla como sea necesario.

1. Usa un validador de YAML para comprobar la validez del archivo. AppSpec 

1. Guarde el archivo como `appspec.yml` en el directorio raíz de la revisión.

1. Ejecute uno de los siguientes comandos para comprobar que ha colocado el AppSpec archivo en el directorio raíz:
   + Para Linux, macOS o Unix:

     ```
     find /path/to/root/directory -name appspec.yml
     ```

     No habrá ningún resultado si el AppSpec archivo no se encuentra allí.
   + Para Windows:

     ```
     dir path\to\root\directory\appspec.yml
     ```

     Si **el archivo no está almacenado allí, aparecerá el mensaje de error AppSpec Archivo no encontrado**.

1. Envíe la revisión a Amazon S3 o GitHub. 

   Para obtener instrucciones, consulte [Enviar una revisión CodeDeploy a Amazon S3 (solo para implementaciones de EC2/on-premise)](application-revisions-push.md).

### AppSpec plantilla de archivo para una implementación local de EC2/con instrucciones
<a name="app-spec-template-server"></a>

**nota**  
 Las implementaciones en instancias de Windows Server no admiten el elemento `runas`. Si va a realizar la implementación en instancias de Windows Server, no la incluya en el archivo. AppSpec 

```
# This is an appspec.yml template file for use with an EC2/On-Premises deployment in CodeDeploy.
# The lines in this template starting with the hashtag symbol are 
#   instructional comments and can be safely left in the file or 
#   ignored.
# For help completing this file, see the "AppSpec File Reference" in the  
#   "CodeDeploy User Guide" at
#   https://docs.aws.amazon.com/codedeploy/latest/userguide/app-spec-ref.html
version: 0.0
# Specify "os: linux" if this revision targets Amazon Linux, 
#   Red Hat Enterprise Linux (RHEL), or Ubuntu Server  
#   instances.
# Specify "os: windows" if this revision targets Windows Server instances.
# (You cannot specify both "os: linux" and "os: windows".)
os: linux 
# os: windows
# During the Install deployment lifecycle event (which occurs between the 
#   BeforeInstall and AfterInstall events), copy the specified files 
#   in "source" starting from the root of the revision's file bundle 
#   to "destination" on the Amazon EC2 instance.
# Specify multiple "source" and "destination" pairs if you want to copy 
#   from multiple sources or to multiple destinations.
# If you are not copying any files to the Amazon EC2 instance, then remove the
#   "files" section altogether. A blank or incomplete "files" section
#   may cause associated deployments to fail.
files:
  - source: 
    destination:
  - source:
    destination:
# For deployments to Amazon Linux, Ubuntu Server, or RHEL instances,
#   you can specify a "permissions" 
#   section here that describes special permissions to apply to the files 
#   in the "files" section as they are being copied over to 
#   the Amazon EC2 instance.
#   For more information, see the documentation.
# If you are deploying to Windows Server instances,
#   then remove the 
#   "permissions" section altogether. A blank or incomplete "permissions"
#   section may cause associated deployments to fail.
permissions:
  - object:
    pattern:
    except:
    owner:
    group:
    mode: 
    acls:
      -
    context:
      user:
      type:
      range:
    type:
      -
# If you are not running any commands on the Amazon EC2 instance, then remove 
#   the "hooks" section altogether. A blank or incomplete "hooks" section
#   may cause associated deployments to fail.
hooks:
# For each deployment lifecycle event, specify multiple "location" entries 
#   if you want to run multiple scripts during that event.
# You can specify "timeout" as the number of seconds to wait until failing the deployment 
#   if the specified scripts do not run within the specified time limit for the 
#   specified event. For example, 900 seconds is 15 minutes. If not specified, 
#   the default is 1800 seconds (30 minutes).
#   Note that the maximum amount of time that all scripts must finish executing 
#   for each individual deployment lifecycle event is 3600 seconds (1 hour). 
#   Otherwise, the deployment will stop and CodeDeploy will consider the deployment
#   to have failed to the Amazon EC2 instance. Make sure that the total number of seconds 
#   that are specified in "timeout" for all scripts in each individual deployment 
#   lifecycle event does not exceed a combined 3600 seconds (1 hour).
# For deployments to Amazon Linux, Ubuntu Server, or RHEL instances,
#   you can specify "runas" in an event to
#   run as the specified user. For more information, see the documentation.
#   If you are deploying to Windows Server instances,
#   remove "runas" altogether.
# If you do not want to run any commands during a particular deployment
#   lifecycle event, remove that event declaration altogether. Blank or 
#   incomplete event declarations may cause associated deployments to fail.
# During the ApplicationStop deployment lifecycle event, run the commands 
#   in the script specified in "location" starting from the root of the 
#   revision's file bundle.
  ApplicationStop:
    - location: 
      timeout:
      runas:
    - location: 
      timeout:
      runas: 
# During the BeforeInstall deployment lifecycle event, run the commands 
#   in the script specified in "location".
  BeforeInstall:
    - location: 
      timeout:
      runas: 
    - location: 
      timeout:
      runas:
# During the AfterInstall deployment lifecycle event, run the commands 
#   in the script specified in "location".
  AfterInstall:
    - location:     
      timeout: 
      runas:
    - location: 
      timeout:
      runas:
# During the ApplicationStart deployment lifecycle event, run the commands 
#   in the script specified in "location".
  ApplicationStart:
    - location:     
      timeout: 
      runas:
    - location: 
      timeout:
      runas:
# During the ValidateService deployment lifecycle event, run the commands 
#   in the script specified in "location".
  ValidateService:
    - location:     
      timeout: 
      runas:
    - location: 
      timeout:
      runas:
```

# Elección de un tipo de repositorio de CodeDeploy
<a name="application-revisions-repository-type"></a>

La ubicación de almacenamiento de los archivos necesarios para CodeDeploy se denomina *repositorio*. El uso de un repositorio depende de la plataforma de informática que se utilice en la implementación.
+ **EC2/en las instalaciones**: para implementar el código de la aplicación en una o varias instancias, el código debe agruparse en un archivo de almacenamiento y colocarse en un repositorio al que CodeDeploy pueda tener acceso durante el proceso de implementación. Tiene que agrupar el contenido implementable y un archivo AppSpec en un archivo de almacenamiento y, a continuación, cargarlo en uno de los tipos de repositorio admitidos por CodeDeploy.
+ **AWS Lambda** y **Amazon ECS**: las implementaciones necesitan un archivo AppSpec al que se pueda tener acceso durante una implementación de una de las siguientes maneras: 
  +  Desde un bucket de Amazon S3. 
  +  Desde el texto escrito directamente en el editor de AppSpec de la consola. Para obtener más información, consulte [Crear una implementación de AWS Lambda Compute Platform (consola)](deployments-create-console-lambda.md) y [Creación de una implementación en una plataforma de informática de Amazon ECS (consola)](deployments-create-console-ecs.md). 
  +  Si utiliza la AWS CLI, puede hacer referencia a un archivo AppSpec que esté en el disco duro o en una unidad de red. Para obtener más información, consulte [Crear una implementación de AWS Lambda Compute Platform (CLI)](deployments-create-lambda-cli.md) y [Creación de una implementación en una plataforma de informática de Amazon ECS (CLI)](deployments-create-ecs-cli.md). 

CodeDeploy admite actualmente los siguientes tipos de repositorio: 


|  |  |  | 
| --- |--- |--- |
| Tipo de repositorio | Detalles del repositorio | Plataforma de informática compatible | 
| Amazon S3 | [Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) (Amazon S3) es la solución de AWS para el almacenamiento seguro y escalable de objetos. Amazon S3 almacena los datos como objetos dentro de buckets. Un objeto consta de un archivo y, opcionalmente, cualquier metadato que describa ese archivo. Para almacenar un objeto en Amazon S3, debe cargar el archivo en un bucket. Al cargar un archivo, puede configurar permisos y metadatos en el objeto. Más información: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/application-revisions-repository-type.html) | Las implementaciones que utilizan las siguientes plataformas de informática pueden almacenar la revisión en un bucket de Amazon S3.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/application-revisions-repository-type.html) | 
| GitHub | Puede almacenar las revisiones de aplicación en repositorios de [GitHub](http://www.github.com). Puede activar una implementación desde un repositorio de GitHub siempre que el código fuente de ese repositorio cambie.Más información:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/application-revisions-repository-type.html) | Solo las implementaciones de EC2/en las instalaciones pueden almacenar la revisión en un repositorio de GitHub. | 
| Bitbucket |  Puede implementar código en grupos de implementación de instancias de EC2 mediante el uso de la [canalización de CodeDeploy](https://bitbucket.org/product/features/pipelines/integrations?p=atlassian/aws-code-deploy) en [Bitbucket Pipelines](https://bitbucket.org/product/features/pipelines). Bitbucket Pipelines ofrece funciones de integración continua e implementación continua (CI/CD), incluidas las [implementaciones de Bitbucket](https://confluence.atlassian.com/bitbucket/bitbucket-deployments-940695276.html). La canalización de CodeDeploy envía primero el artefacto a un bucket de S3 especificado y, a continuación, implementa el artefacto de código desde el bucket. Más información:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/application-revisions-repository-type.html)  | Solo las implementaciones de EC2/en las instalaciones pueden almacenar la revisión en un repositorio de BitBucket. | 

**nota**  
Una implementación de AWS Lambda solo funciona con un repositorio de Amazon S3.

# Enviar una revisión CodeDeploy a Amazon S3 (solo para implementaciones de EC2/on-premise)
<a name="application-revisions-push"></a>

Tras planificar la revisión tal y como se describe en [Planificación de una revisión de CodeDeploy](application-revisions-plan.md) y añadir un AppSpec archivo a la revisión tal y como se describe en[Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md), estará listo para agrupar los archivos de los componentes y enviar la revisión a Amazon S3. Para las implementaciones en instancias de Amazon EC2, después de enviar la revisión, puede CodeDeploy utilizarla para implementar la revisión desde Amazon S3 en las instancias.

**nota**  
CodeDeploy también se puede usar para implementar las revisiones que se han transferido. GitHub Para obtener más información, consulte GitHub la documentación.

Suponemos que ya ha seguido las instrucciones de [Empezar con CodeDeploy](getting-started-codedeploy.md) para configurar la AWS CLI. Esto resulta de gran importancia para ejecutar el comando **push** que se describe más adelante.

Asegúrese de que tiene un bucket de Amazon S3. Siga las instrucciones de [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html).

Si la implementación se realiza en instancias de Amazon EC2, el bucket de Amazon S3 de destino se debe crear o encontrar en la misma región que las instancias de destino. Por ejemplo, si quiere implementar una revisión en algunas instancias de la región Este de EE. UU. (Norte de Virginia) y otras instancias en la región Oeste de EE. UU. (Oregón), debe tener un bucket en la región Este de EE. UU. (Norte de Virginia) con una copia de la revisión y otro en la región Oste de EE. UU. (Oregón) con otra copia de la misma revisión. En este caso, debería crear dos implementaciones independientes, una en la región Este de EE. UU. (Norte de Virginia) y otra en la región Oeste de EE. UU. (Oregón), aunque la revisión es la misma en ambas regiones y en ambos buckets.

Debe tener permisos para cargar en el bucket de Amazon S3. Puede especificar estos permisos mediante una política de bucket de Amazon S3. Por ejemplo, en la siguiente política de bucket de Amazon S3, el uso del carácter comodín (\$1) permite `111122223333` a la AWS cuenta cargar archivos en cualquier directorio del bucket de Amazon S3 denominado`amzn-s3-demo-bucket`:

```
{
    "Statement": [
        {
            "Action": [
                "s3:PutObject"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "111122223333"
                ]
            }
        }
    ]
}
```

Para ver el ID de su AWS cuenta, consulte [Cómo encontrar el ID de su AWS cuenta](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId).

Para aprender a generar y vincular una política de bucket de Amazon S3, consulte [Ejemplos de políticas de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).

El usuario que llama al comando **push** debe disponer, como mínimo, de permisos para cargar la revisión en cada bucket de Amazon S3 de destino. Por ejemplo, la siguiente política permite que el usuario cargue revisiones en cualquier lugar del bucket de Amazon S3 denominado `amzn-s3-demo-bucket`:

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
        }
    ]
}
```

------

Para obtener información sobre cómo crear y vincular una política de IAM, consulte [Trabajo con políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console).

## Impulsa una revisión mediante el AWS CLI
<a name="push-with-cli"></a>

**nota**  
 El `push` comando agrupa los artefactos de la aplicación y un AppSpec archivo en una revisión. El formato de archivo de esta revisión es un archivo ZIP comprimido. El comando no se puede usar con una implementación de AWS Lambda o Amazon ECS porque cada una espera una revisión que sea un archivo con formato JSON o YAML. AppSpec 

Ejecute el comando **push** para agrupar y enviar la revisión de una implementación. Sus parámetros son:
+  **--application-name**: (cadena) obligatorio. El nombre de la aplicación CodeDeploy que se asociará a la revisión de la aplicación. 
+  **--s3-location**: (cadena) obligatorio. Información sobre la ubicación de la revisión de la aplicación que se cargará en Amazon S3. Debe especificar un bucket de Amazon S3 y una clave. La clave es el nombre de la revisión. CodeDeploy comprime el contenido antes de cargarlo. Utilice el formato `s3://amzn-s3-demo-bucket/your-key.zip`. 
+  **--ignore-hidden-files** o **--no-ignore-hidden-files**: (booleano) opcional. Utilice la marca `--no-ignore-hidden-files` (el valor predeterminado) para empaquetar y cargar archivos ocultos en Amazon S3. Utilice la marca `--ignore-hidden-files` para no empaquetar y cargar archivos ocultos en Amazon S3. 
+  **--source** (cadena) opcional. La ubicación del contenido que se va a implementar y el AppSpec archivo de la máquina de desarrollo que se va a comprimir y cargar en Amazon S3. La ubicación se especifica como una ruta relativa al directorio actual. Si no se especifica la ruta relativa o si se utiliza un único punto para la ruta ("."), se utiliza el directorio actual. 
+  **--description** (cadena) opcional. Un comentario que resume la revisión de la aplicación. Si no se especifica, se utiliza la cadena predeterminada «Cargado por AWS CLI hora UTC», donde «hora» es la hora actual del sistema en hora universal coordinada (UTC). 

Puede utilizar el AWS CLI para enviar una revisión para una implementación de Amazon EC2. Un comando de envío de ejemplo tiene este aspecto: 

En Linux, macOS o Unix:

```
aws deploy push \
  --application-name WordPress_App \
  --description "This is a revision for the application WordPress_App" \
  --ignore-hidden-files \
  --s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
  --source .
```

 En Windows: 

```
aws deploy push --application-name WordPress_App --description "This is a revision for the application WordPress_App" --ignore-hidden-files --s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip --source .
```

 Este comando hace lo siguiente: 
+  Asocia los archivos agrupados con una aplicación denominada `WordPress_App`. 
+  Adjunta una descripción a la revisión. 
+  Ignora los archivos ocultos. 
+  Asigna a la revisión el nombre `WordPressApp.zip` y la envía a un bucket llamado `amzn-s3-demo-bucket`. 
+  Agrupa todos los archivos del directorio raíz en la revisión. 

Cuando la transferencia se realice correctamente, puede utilizar la consola AWS CLI o la CodeDeploy consola para implementar la revisión desde Amazon S3. Para implementar esta revisión con AWS CLI: 

 En Linux, macOS o Unix: 

```
aws deploy create-deployment \
  --application-name WordPress_App \ 
  --deployment-config-name your-deployment-config-name \ 
  --deployment-group-name your-deployment-group-name \ 
  --s3-location bucket=amzn-s3-demo-bucket,key=WordPressApp.zip,bundleType=zip
```

 En Windows: 

```
aws deploy create-deployment --application-name WordPress_App --deployment-config-name your-deployment-config-name --deployment-group-name your-deployment-group-name --s3-location bucket=amzn-s3-demo-bucket,key=WordPressApp.zip,bundleType=zip
```

 Para obtener más información, consulte [Cree una implementación con CodeDeploy](deployments-create.md). 

# Vea los detalles de la revisión de la aplicación con CodeDeploy
<a name="application-revisions-view-details"></a>

Puede usar la CodeDeploy consola AWS CLI, la o la CodeDeploy APIs para ver los detalles de todas las revisiones de la aplicación que están registradas en su AWS cuenta para una aplicación específica.

Para obtener información sobre el registro de una revisión, consulte [Registre una revisión de aplicación en Amazon S3 con CodeDeploy](application-revisions-register.md).

**Topics**
+ [Visualización de los detalles de una revisión de aplicación (consola)](#application-revisions-view-details-console)
+ [Visualización de los detalles de una revisión de aplicación (CLI)](#application-revisions-view-details-cli)

## Visualización de los detalles de una revisión de aplicación (consola)
<a name="application-revisions-view-details-console"></a>

Para ver los detalles de una revisión de aplicación:

1. Inicie sesión en Consola de administración de AWS y abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**nota**  
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).

1. En el panel de navegación, expanda **Implementar** y elija **Aplicaciones**.
**nota**  
Si no se muestra ninguna entrada, asegúrese de seleccionar la región correcta. En la barra de navegación, en el selector de regiones, elija una de las regiones que aparecen en [Región y puntos finales](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en. *Referencia general de AWS* CodeDeploy solo se admite en estas regiones.

1. Elija el nombre de la aplicación que tiene la revisión que desea ver.

1. En la página **Application details (Detalles de la aplicación)**, elija la pestaña **Revisions (Revisiones)** y examine la lista de revisiones registradas para la aplicación. Elija una revisión y, a continuación, elija **View details (Ver detalles)**.

## Visualización de los detalles de una revisión de aplicación (CLI)
<a name="application-revisions-view-details-cli"></a>

Para usar el AWS CLI para ver la revisión de una aplicación, ****get-application-revision****ejecute el comando o el ****list-application-revisions****comando.

**nota**  
 Las referencias GitHub se aplicarán únicamente a las implementaciones de EC2/on-premise. Las revisiones de las AWS Lambda implementaciones no funcionan con. GitHub 

Para ver detalles de una sola revisión de aplicación, ejecute el comando [get-application-revision](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-application-revision.html) especificando: 
+ El nombre de la aplicación. Para obtener el nombre de la aplicación, llame al comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ En el caso de una revisión almacenada en GitHub, el nombre del GitHub repositorio y el identificador de la confirmación que hace referencia a la revisión de la aplicación que se envió al repositorio.
+ En el caso de una revisión almacenada en Amazon S3, el nombre del bucket de Amazon S3 que contiene la revisión, el nombre y el tipo de archivo del archivo cargado y, opcionalmente, el identificador de versión de Amazon S3 del archivo archivado y ETag. Si el identificador de la versión ETag, o ambos, se especificaron durante una llamada a [register-application-revision](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-application-revision.html), deben especificarse aquí.

Para ver detalles de varias revisiones de la aplicación, ejecute el comando [list-application-revisions](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-application-revisions.html) especificando:
+ El nombre de la aplicación. Para obtener el nombre de la aplicación, llame al comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ Si solo desea ver los detalles de las revisiones de la aplicación en Amazon S3, el nombre del bucket de Amazon S3 que contiene las revisiones.
+ Si solo desea ver los detalles de las revisiones de la aplicación en Amazon S3, una cadena de prefijo para limitar la búsqueda a las revisiones de la aplicación en Amazon S3. (Si no se especifica, CodeDeploy mostrará una lista de todas las revisiones de la aplicación Amazon S3 que coincidan).
+ Opcionalmente, si se deben mostrar los detalles de las revisiones en función de si son revisiones de destino de un grupo de implementaciones. (Si no se especifica, CodeDeploy mostrará una lista de todas las revisiones coincidentes).
+ Opcionalmente, el nombre de la columna y el orden en que deben mostrarse la lista de detalles de las revisiones. (Si no se especifica, CodeDeploy mostrará los resultados en un orden arbitrario).

Es posible incluir todas las revisiones, o solo las revisiones almacenadas en Amazon S3. No puede enumerar solo las revisiones almacenadas en GitHub.

# Registre una revisión de aplicación en Amazon S3 con CodeDeploy
<a name="application-revisions-register"></a>

Si ya ha ejecutado el comando [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) para enviar una revisión de la aplicación a Amazon S3, no es necesario registrar la revisión. Sin embargo, si sube una revisión a Amazon S3 por otros medios y desea que la revisión aparezca en la CodeDeploy consola o a través de AWS CLI, siga estos pasos para registrar primero la revisión.

Si ha subido una revisión de una aplicación a un GitHub repositorio y desea que la revisión aparezca en la CodeDeploy consola o a través de AWS CLI ella, también debe seguir estos pasos.

Solo puede usar el AWS CLI o CodeDeploy APIs para registrar las revisiones de la aplicación en Amazon S3 o GitHub.

**Topics**
+ [Registrar una revisión en Amazon S3 con CodeDeploy (CLI)](#application-revisions-register-s3)
+ [Registrar una revisión GitHub con CodeDeploy (CLI)](#application-revisions-register-github)

## Registrar una revisión en Amazon S3 con CodeDeploy (CLI)
<a name="application-revisions-register-s3"></a>

1. Cargue la revisión en Amazon S3.

1. Ejecute el comando [register-application-revision](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-application-revision.html) especificando lo siguiente:
   + El nombre de la aplicación. Para ver una lista de nombres de aplicaciones, llame al comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
   + Información acerca de la revisión que desea registrar:
     + Nombre del bucket de Amazon S3 que contiene la revisión.
     + Nombre y tipo de archivo de la revisión cargada. En el AWS Lambda caso de las implementaciones, la revisión es un AppSpec archivo escrito en JSON o YAML. En el caso de las implementaciones de EC2/on-premise, la revisión contiene una versión de los archivos fuente que CodeDeploy se implementarán en las instancias o los scripts que CodeDeploy se ejecutarán en las instancias.
**nota**  
Los formatos de archivo tar y tar comprimido (.tar y .tar.gz) no son compatibles con las instancias de Windows Server.
     + (Opcional) Identificador de versión de Amazon S3 correspondiente a la versión. (Si no se especifica el identificador de la versión, se CodeDeploy utilizará la versión más reciente).
     + (Opcional) La de la revisión ETag. (Si no ETag se especifica, CodeDeploy omitirá la validación del objeto).
   + (Opcional) Una descripción que desee asociar a la revisión.

La información sobre las revisiones de Amazon S3 puede especificarse en la línea de comandos utilizando la sintaxis siguiente como parte de la llamada a **register-application-revision**. (`version` y `eTag` son opcionales).

Para un archivo de revisión para una implementación de EC2/en las instalaciones:

```
--s3-location bucket=string,key=string,bundleType=tar|tgz|zip,version=string,eTag=string
```

Para un archivo de revisión para una implementación de AWS Lambda:

```
--s3-location bucket=string,key=string,bundleType=JSON|YAML,version=string,eTag=string
```

## Registrar una revisión GitHub con CodeDeploy (CLI)
<a name="application-revisions-register-github"></a>

**nota**  
AWS Lambda las implementaciones no funcionan con GitHub. 

1. Sube la revisión a tu GitHub repositorio.

1. Ejecute el comando [register-application-revision](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-application-revision.html) especificando lo siguiente:
   + El nombre de la aplicación. Para ver una lista de nombres de aplicaciones, llame al comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
   + Información acerca de la revisión que desea registrar:
     + El nombre de GitHub usuario o grupo asignado al repositorio que contiene la revisión, seguido de una barra diagonal (`/`) seguida del nombre del repositorio.
     + El ID de la confirmación correspondiente a la revisión en el repositorio.
   + (Opcional) Una descripción que desee asociar a la revisión.

La información sobre una revisión se GitHub puede especificar en la línea de comandos, utilizando esta sintaxis como parte de la **register-application-revision** llamada:

```
--github-location repository=string,commitId=string
```