

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.

# Configuración manual para desarrollar componentes personalizados con TOE de AWS
<a name="toe-get-started"></a>

La aplicación Ejecutor y orquestador de tareas de AWS (TOE de AWS) es una aplicación independiente que crea, valida y ejecuta comandos dentro de un marco de definición de componentes. AWS los servicios se pueden utilizar TOE de AWS para organizar los flujos de trabajo, instalar software, modificar las configuraciones del sistema y probar compilaciones de imágenes.

Siga estos pasos para instalar manualmente la TOE de AWS aplicación y utilizarla como una aplicación independiente para desarrollar componentes personalizados. Image Builder se encarga de estos pasos si utiliza la consola o los AWS CLI comandos de Image Builder para crear componentes personalizados. Para obtener más información, consulte [Cree componentes personalizados con Generador de imágenes](create-component.md).

**Topics**
+ [Verificar la firma de la descarga de la TOE de AWS instalación](awstoe-verify-sig.md)
+ [Paso 1: Instalar TOE de AWS](#toe-start-install)
+ [Paso 2: Defina AWS las credenciales](#toe-start-credentials)
+ [Paso 3: desarrollar los documentos de los componentes a nivel local](#toe-start-develop)
+ [Paso 4: Validar TOE de AWS los componentes](#toe-start-validate)
+ [Paso 5: ejecutar TOE de AWS los componentes](#toe-start-run)

## Paso 1: Instalar TOE de AWS
<a name="toe-start-install"></a>

Para desarrollar componentes localmente, descargue e instale la TOE de AWS aplicación.

1. 

**Descargue la TOE de AWS aplicación**

   Para instalarla TOE de AWS, elija el enlace de descarga adecuado para su arquitectura y plataforma. Para ver la lista completa de los enlaces de descarga de las aplicaciones, consulte [TOE de AWS descargas](toe-component-manager.md#toe-downloads)
**importante**  
AWS está eliminando gradualmente la compatibilidad con las versiones 1.0 y 1.1 de TLS. Para acceder al depósito de S3 para realizar TOE de AWS descargas, el software de su cliente debe usar la versión 1.2 o posterior de TLS. Para obtener más información, consulte esta [entrada de blog de seguridad de AWS](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/).

1. 

**Verificación de la firma**

   Los pasos para verificar la descarga dependen de la plataforma de servidor en la que ejecute la TOE de AWS aplicación después de instalarla. Para verificar la descarga en un servidor Linux, consulte [Verificación de la firma en Linux o macOS](awstoe-verify-sig.md#awstoe-verify-sig-linux). Para comprobar la descarga en un servidor Windows, consulte [Verificación de la firma en Windows](awstoe-verify-sig.md#awstoe-verify-sig-win).

**nota**  
TOE de AWS se invoca directamente desde su ubicación de descarga. No es necesario realizar un paso de instalación independiente. Esto también significa que TOE de AWS puede realizar cambios en el entorno local.  
Para asegurarse de aislar los cambios durante el desarrollo de los componentes, le recomendamos que utilice una EC2 instancia para desarrollar y probar TOE de AWS los componentes.

## Paso 2: Defina AWS las credenciales
<a name="toe-start-credentials"></a>

 TOE de AWS requiere AWS credenciales para conectarse a otros Servicios de AWS, como Amazon S3 y Amazon CloudWatch, al ejecutar tareas, como: 
+ Descargar TOE de AWS documentos desde una ruta de Amazon S3 proporcionada por el usuario.
+ Ejecutar módulos de acción `S3Download` o `S3Upload`.
+ La transmisión de registros a CloudWatch, cuando está habilitada.

Si TOE de AWS ejecutas una EC2 instancia, la ejecución TOE de AWS utiliza los mismos permisos que la función de IAM asociada a la EC2 instancia.

Para obtener más información sobre las funciones de IAM para EC2, consulte [Funciones de IAM para Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html). EC2

Los siguientes ejemplos muestran cómo configurar las AWS credenciales mediante las variables de `AWS_SECRET_ACCESS_KEY` entorno `AWS_ACCESS_KEY_ID` y. 

Para establecer estas variables en Linux, MacOS, o Unix, utilice `export`:

```
export AWS_ACCESS_KEY_ID=your_access_key_id
```

```
export AWS_SECRET_ACCESS_KEY=your_secret_access_key
```

Para configurar estas variables en Windows mediante PowerShell, utilice`$env`.

```
$env:AWS_ACCESS_KEY_ID=your_access_key_id
```

```
$env:AWS_SECRET_ACCESS_KEY=your_secret_access_key
```

Para establecer estas variables en Windows con símbolo del sistema, utilice `set`.

```
set AWS_ACCESS_KEY_ID=your_access_key_id
```

```
set AWS_SECRET_ACCESS_KEY=your_secret_access_key
```

## Paso 3: desarrollar los documentos de los componentes a nivel local
<a name="toe-start-develop"></a>

Los componentes se crean con documentos YAML de texto simple. Para obtener más información sobre sintaxis de documentos, consulte [Utilice el marco de documentos de TOE de AWS componentes para componentes personalizados](toe-use-documents.md).

Los siguientes son ejemplos de documentos de componentes *Hola, mundo* que le ayudarán a empezar.

------
#### [ Linux ]

Algunos de los ejemplos de componentes de Linux de esta guía hacen referencia a un archivo de documento de componentes denominado `hello-world-linux.yml`. Puede utilizar el siguiente documento para empezar con esos ejemplos.

```
name: Hello World
description: This is hello world testing document for Linux.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the build phase.'
  - name: validate
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the validate phase.'
  - name: test
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the test phase.'
```

------
#### [ Windows ]

Algunos de los ejemplos de componentes de Windows de esta guía hacen referencia a un archivo de documento de componentes denominado `hello-world-windows.yml`. Puede utilizar el siguiente documento para empezar con esos ejemplos.

```
name: Hello World
description: This is Hello World testing document for Windows.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: HelloWorldStep
        action: ExecutePowerShell
        inputs:
          commands:
            - Write-Host 'Hello World from the build phase.'
  - name: validate
    steps:
      - name: HelloWorldStep
        action: ExecutePowerShell
        inputs:
          commands:
            - Write-Host 'Hello World from the validate phase.'
  - name: test
    steps:
      - name: HelloWorldStep
        action: ExecutePowerShell
        inputs:
          commands:
            - Write-Host 'Hello World from the test phase.'
```

------
#### [ macOS ]

Algunos de los ejemplos de componentes de macOS de esta guía hacen referencia a un archivo de documento de componentes denominado `hello-world-macos.yml`. Puede utilizar el siguiente documento para empezar con esos ejemplos.

```
name: Hello World
description: This is hello world testing document for macOS.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the build phase.'
  - name: validate
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the validate phase.'
  - name: test
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the test phase.'
```

------

## Paso 4: Validar TOE de AWS los componentes
<a name="toe-start-validate"></a>

Puede validar la sintaxis de TOE de AWS los componentes localmente con la TOE de AWS aplicación. Los siguientes ejemplos muestran el `validate` comando de la TOE de AWS aplicación para validar la sintaxis de un componente sin ejecutarlo.

**nota**  
La TOE de AWS aplicación solo puede validar la sintaxis del componente para el sistema operativo actual. Por ejemplo, cuando se ejecuta `awstoe.exe` en Windows, no se puede validar la sintaxis de un documento de Linux que utilice el módulo de acción `ExecuteBash`.

Linux o macOS

```
awstoe validate --documents /home/user/hello-world.yml
```

Windows

```
awstoe.exe validate --documents C:\Users\user\Documents\hello-world.yml
```

## Paso 5: ejecutar TOE de AWS los componentes
<a name="toe-start-run"></a>

La TOE de AWS aplicación puede ejecutar una o más fases de documentos específicos mediante el argumento de la línea de `--phases` comandos. Los valores admitidos de `--phases` son `build`, `validate` y `test`. Se pueden introducir varios valores de fase como valores separados por comas.

Al proporcionar una lista de fases, la TOE de AWS aplicación ejecuta secuencialmente las fases especificadas de cada documento. Por ejemplo, TOE de AWS ejecuta las `validate` fases `build` y de`document1.yaml`, seguidas de `validate` las fases `build` y de`document2.yaml`.

Para garantizar que sus registros se almacenen de forma segura y se conserven para la solución de problemas, le recomendamos configurar el almacenamiento de registros en Amazon S3. En Generador de Imágenes, la ubicación de Amazon S3 para publicar los registros se especifica en la configuración de infraestructura. Para obtener más información acerca de la configuración de la infraestructura, consulte [Administre la configuración de la infraestructura de Generador de imágenes](manage-infra-config.md).

Si no se proporciona una lista de fases, la TOE de AWS aplicación ejecuta todas las fases en el orden indicado en el documento YAML.

Para ejecutar fases específicas en uno o varios documentos, utilice los siguientes comandos.

Fase única

```
awstoe run --documents hello-world.yml --phases build
```

Fases múltiples

```
awstoe run --documents {{hello-world.yml}} --phases build,test
```

**Ejecución de documentos**  
Ejecución de todas las fases en un solo documento

```
awstoe run --documents {{documentName.yaml}}
```

Ejecución de todas las fases en varios documentos

```
awstoe run --documents {{documentName1.yaml}},{{documentName2.yaml}}
```

Introduzca la información de Amazon S3 para cargar TOE de AWS los registros desde una ruta local definida por el usuario (recomendado)

```
awstoe run --documents {{documentName.yaml}} --log-s3-bucket-name {{amzn-s3-demo-destination-bucket}} --log-s3-key-prefix {{S3KeyPrefix}} --log-s3-bucket-owner {{S3BucketOwner}} --log-directory {{local_path}}
```

Ejecución de todas las fases en un solo documento y muestre todos los registros en la consola

```
awstoe run --documents {{documentName.yaml}} --trace
```

Comando de ejemplo:

```
awstoe run --documents {{s3://bucket/key/doc.yaml}} --phases {{build,validate}}
```

Ejecución del documento con un identificador único

```
awstoe run --documents {{documentName.yaml}} --execution-id {{user-provided-id}} --phases {{build,test}}
```

Obtenga ayuda con TOE de AWS

```
awstoe --help
```