# AWS Batch Exemplos do usando a AWS CLI
<a name="cli_batch_code_examples"></a>

Os exemplos de código a seguir mostram como realizar ações e implementar cenários comuns usando o AWS Command Line Interface com o AWS Batch.

*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.

Cada exemplo inclui um link para o código-fonte completo, em que você pode encontrar instruções sobre como configurar e executar o código.

**Topics**
+ [Ações](#actions)

## Ações
<a name="actions"></a>

### `cancel-job`
<a name="batch_CancelJob_cli_topic"></a>

O código de exemplo a seguir mostra como usar `cancel-job`.

**AWS CLI**  
**Para cancelar um trabalho**  
Este exemplo cancela um trabalho com o ID de trabalho especificado.  
Comando:  

```
aws batch cancel-job --job-id bcf0b186-a532-4122-842e-2ccab8d54efb --reason "Cancelling job."
```
+  Para ver detalhes da API, consulte [CancelJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/cancel-job.html) na *Referência de comandos da AWS CLI*. 

### `create-compute-environment`
<a name="batch_CreateComputeEnvironment_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-compute-environment`.

**AWS CLI**  
**Para criar um ambiente computacional gerenciado com instâncias sob demanda**  
Este exemplo cria um ambiente computacional gerenciado com tipos específicos de instância C4 que são executados sob demanda. O ambiente computacional é chamado de C4OnDemand.  
Comando:  

```
aws batch create-compute-environment --cli-input-json file://<path_to_json_file>/C4OnDemand.json
```
Formato de arquivo JSON:  

```
{
  "computeEnvironmentName": "C4OnDemand",
  "type": "MANAGED",
  "state": "ENABLED",
  "computeResources": {
    "type": "EC2",
    "minvCpus": 0,
    "maxvCpus": 128,
    "desiredvCpus": 48,
    "instanceTypes": [
      "c4.large",
      "c4.xlarge",
      "c4.2xlarge",
      "c4.4xlarge",
      "c4.8xlarge"
    ],
    "subnets": [
      "subnet-220c0e0a",
      "subnet-1a95556d",
      "subnet-978f6dce"
    ],
    "securityGroupIds": [
      "sg-cf5093b2"
    ],
    "ec2KeyPair": "id_rsa",
    "instanceRole": "ecsInstanceRole",
    "tags": {
      "Name": "Batch Instance - C4OnDemand"
    }
  },
  "serviceRole": "arn:aws:iam::012345678910:role/AWSBatchServiceRole"
}
```
Resultado:  

```
{
    "computeEnvironmentName": "C4OnDemand",
    "computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/C4OnDemand"
}
```
**Para criar um ambiente de computação gerenciado com instâncias spot**  
Este exemplo cria um ambiente de computação gerenciado com o tipo de instância M4 que é executado quando a sugestão de preço do Spot é igual ou inferior a 20% do preço sob demanda do tipo de instância. O ambiente computacional é chamado de M4Spot.  
Comando:  

```
aws batch create-compute-environment --cli-input-json file://<path_to_json_file>/M4Spot.json
```
Formato de arquivo JSON:  

```
{
  "computeEnvironmentName": "M4Spot",
  "type": "MANAGED",
  "state": "ENABLED",
  "computeResources": {
    "type": "SPOT",
    "spotIamFleetRole": "arn:aws:iam::012345678910:role/aws-ec2-spot-fleet-role",
    "minvCpus": 0,
    "maxvCpus": 128,
    "desiredvCpus": 4,
    "instanceTypes": [
      "m4"
    ],
    "bidPercentage": 20,
    "subnets": [
      "subnet-220c0e0a",
      "subnet-1a95556d",
      "subnet-978f6dce"
    ],
    "securityGroupIds": [
      "sg-cf5093b2"
    ],
    "ec2KeyPair": "id_rsa",
    "instanceRole": "ecsInstanceRole",
    "tags": {
      "Name": "Batch Instance - M4Spot"
    }
  },
  "serviceRole": "arn:aws:iam::012345678910:role/AWSBatchServiceRole"
}
```
Resultado:  

```
{
    "computeEnvironmentName": "M4Spot",
    "computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/M4Spot"
}
```
+  Para ver detalhes da API, consulte [CreateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-compute-environment.html) na *Referência de comandos da AWS CLI*. 

### `create-job-queue`
<a name="batch_CreateJobQueue_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-job-queue`.

**AWS CLI**  
**Para criar uma fila de trabalhos de baixa prioridade com um único ambiente computacional**  
Este exemplo cria uma fila de trabalhos chamada LowPriority que usa o ambiente de computação M4Spot.  
Comando:  

```
aws batch create-job-queue --cli-input-json file://<path_to_json_file>/LowPriority.json
```
Formato de arquivo JSON:  

```
{
  "jobQueueName": "LowPriority",
  "state": "ENABLED",
  "priority": 10,
  "computeEnvironmentOrder": [
    {
      "order": 1,
      "computeEnvironment": "M4Spot"
    }
  ]
}
```
Resultado:  

```
{
    "jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/LowPriority",
    "jobQueueName": "LowPriority"
}
```
**Para criar uma fila de trabalhos de alta prioridade com dois ambientes computacionais**  
Este exemplo cria uma fila de trabalhos chamada HighPriority que usa o ambiente de computação C4OnDemand com uma ordem de 1 e o ambiente de computação M4Spot com uma ordem de 2. O programador tentará primeiro colocar trabalhos no ambiente computacional C4OnDemand.  
Comando:  

```
aws batch create-job-queue --cli-input-json file://<path_to_json_file>/HighPriority.json
```
Formato de arquivo JSON:  

```
{
  "jobQueueName": "HighPriority",
  "state": "ENABLED",
  "priority": 1,
  "computeEnvironmentOrder": [
    {
      "order": 1,
      "computeEnvironment": "C4OnDemand"
    },
    {
      "order": 2,
      "computeEnvironment": "M4Spot"
    }
  ]
}
```
Resultado:  

```
{
    "jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
    "jobQueueName": "HighPriority"
}
```
+  Para ver detalhes da API, consulte [CreateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-job-queue.html) na *Referência de comandos da AWS CLI*. 

### `delete-compute-environment`
<a name="batch_DeleteComputeEnvironment_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-compute-environment`.

**AWS CLI**  
**Para excluir um ambiente de computação**  
Este exemplo exclui o ambiente de computação P2OnDemand.  
Comando:  

```
aws batch delete-compute-environment --compute-environment P2OnDemand
```
+  Para ver detalhes da API, consulte [DeleteComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-compute-environment.html) na *Referência de comandos da AWS CLI*. 

### `delete-job-queue`
<a name="batch_DeleteJobQueue_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-job-queue`.

**AWS CLI**  
**Para excluir uma fila de trabalhos**  
Este exemplo exclui a fila de trabalho GPGPU.  
Comando:  

```
aws batch delete-job-queue --job-queue GPGPU
```
+  Para ver detalhes da API, consulte [DeleteJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-job-queue.html) na *Referência de comandos da AWS CLI*. 

### `deregister-job-definition`
<a name="batch_DeregisterJobDefinition_cli_topic"></a>

O código de exemplo a seguir mostra como usar `deregister-job-definition`.

**AWS CLI**  
**Como cancelar o registro de uma definição de trabalho**  
Este exemplo cancela o registro de uma definição de trabalho chamada sleep10.  
Comando:  

```
aws batch deregister-job-definition --job-definition sleep10
```
+  Para ver detalhes da API, consulte [DeregisterJobDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/deregister-job-definition.html) na *Referência de comandos da AWS CLI*. 

### `describe-compute-environments`
<a name="batch_DescribeComputeEnvironments_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-compute-environments`.

**AWS CLI**  
**Como descrever um ambiente de computação**  
Este exemplo descreve o ambiente de computação P2OnDemand.  
Comando:  

```
aws batch describe-compute-environments --compute-environments P2OnDemand
```
Resultado:  

```
{
    "computeEnvironments": [
        {
            "status": "VALID",
            "serviceRole": "arn:aws:iam::012345678910:role/AWSBatchServiceRole",
            "computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/P2OnDemand",
            "computeResources": {
                "subnets": [
                    "subnet-220c0e0a",
                    "subnet-1a95556d",
                    "subnet-978f6dce"
                ],
                "tags": {
                    "Name": "Batch Instance - P2OnDemand"
                },
                "desiredvCpus": 48,
                "minvCpus": 0,
                "instanceTypes": [
                    "p2"
                ],
                "securityGroupIds": [
                    "sg-cf5093b2"
                ],
                "instanceRole": "ecsInstanceRole",
                "maxvCpus": 128,
                "type": "EC2",
                "ec2KeyPair": "id_rsa"
            },
            "statusReason": "ComputeEnvironment Healthy",
            "ecsClusterArn": "arn:aws:ecs:us-east-1:012345678910:cluster/P2OnDemand_Batch_2c06f29d-d1fe-3a49-879d-42394c86effc",
            "state": "ENABLED",
            "computeEnvironmentName": "P2OnDemand",
            "type": "MANAGED"
        }
    ]
}
```
+  Consulte detalhes da API em [DescribeComputeEnvironments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-compute-environments.html) na *Referência de comandos da AWS CLI*. 

### `describe-job-definitions`
<a name="batch_DescribeJobDefinitions_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-job-definitions`.

**AWS CLI**  
**Para descrever as definições de trabalhos ativos**  
Este exemplo descreve todas as suas definições de trabalho ativas.  
Comando:  

```
aws batch describe-job-definitions --status ACTIVE
```
Resultado:  

```
{
    "jobDefinitions": [
        {
            "status": "ACTIVE",
            "jobDefinitionArn": "arn:aws:batch:us-east-1:012345678910:job-definition/sleep60:1",
            "containerProperties": {
                "mountPoints": [],
                "parameters": {},
                "image": "busybox",
                "environment": {},
                "vcpus": 1,
                "command": [
                    "sleep",
                    "60"
                ],
                "volumes": [],
                "memory": 128,
                "ulimits": []
            },
            "type": "container",
            "jobDefinitionName": "sleep60",
            "revision": 1
        }
    ]
}
```
+  Para ver detalhes da API, consulte [DescribeJobDefinitions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-job-definitions.html) na *Referência de comandos da AWS CLI*. 

### `describe-job-queues`
<a name="batch_DescribeJobQueues_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-job-queues`.

**AWS CLI**  
**Para descrever uma fila de trabalhos**  
Este exemplo descreve a fila de trabalhos HighPriority.  
Comando:  

```
aws batch describe-job-queues --job-queues HighPriority
```
Resultado:  

```
{
    "jobQueues": [
        {
            "status": "VALID",
            "jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
            "computeEnvironmentOrder": [
                {
                    "computeEnvironment": "arn:aws:batch:us-east-1:012345678910:compute-environment/C4OnDemand",
                    "order": 1
                }
            ],
            "statusReason": "JobQueue Healthy",
            "priority": 1,
            "state": "ENABLED",
            "jobQueueName": "HighPriority"
        }
    ]
}
```
+  Para ver detalhes da API, consulte [DescribeJobQueues](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-job-queues.html) na *Referência de comandos da AWS CLI*. 

### `describe-jobs`
<a name="batch_DescribeJobs_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-jobs`.

**AWS CLI**  
**Para descrever um trabalho**  
O exemplo `describe-jobs` a seguir descreve um trabalho com o ID de trabalho especificado.  

```
aws batch describe-jobs \
    --jobs bcf0b186-a532-4122-842e-2ccab8d54efb
```
Resultado:  

```
{
    "jobs": [
        {
            "status": "SUBMITTED",
            "container": {
                "mountPoints": [],
                "image": "busybox",
                "environment": [],
                "vcpus": 1,
                "command": [
                    "sleep",
                    "60"
                ],
                "volumes": [],
                "memory": 128,
                "ulimits": []
            },
            "parameters": {},
            "jobDefinition": "arn:aws:batch:us-east-1:012345678910:job-definition/sleep60:1",
            "jobQueue": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
            "jobId": "bcf0b186-a532-4122-842e-2ccab8d54efb",
            "dependsOn": [],
            "jobName": "example",
            "createdAt": 1480483387803
        }
    ]
}
```
+  Para ver detalhes da API, consulte [DescribeJobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-jobs.html) na *Referência de comandos da AWS CLI*. 

### `list-jobs`
<a name="batch_ListJobs_cli_topic"></a>

O código de exemplo a seguir mostra como usar `list-jobs`.

**AWS CLI**  
**Para listar trabalhos em execução**  
Este exemplo lista os trabalhos em execução na fila de trabalhos HighPriority.  
Comando:  

```
aws batch list-jobs --job-queue HighPriority
```
Resultado:  

```
{
    "jobSummaryList": [
        {
            "jobName": "example",
            "jobId": "e66ff5fd-a1ff-4640-b1a2-0b0a142f49bb"
        }
    ]
}
```
**Para listar trabalhos enviados**  
Este exemplo lista trabalhos na fila de trabalhos HighPriority que estão no status de trabalho ENVIADO.  
Comando:  

```
aws batch list-jobs --job-queue HighPriority --job-status SUBMITTED
```
Resultado:  

```
{
    "jobSummaryList": [
        {
            "jobName": "example",
            "jobId": "68f0c163-fbd4-44e6-9fd1-25b14a434786"
        }
    ]
}
```
+  Consulte detalhes da API em [ListJobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/list-jobs.html) na *Referência de comandos da AWS CLI*. 

### `register-job-definition`
<a name="batch_RegisterJobDefinition_cli_topic"></a>

O código de exemplo a seguir mostra como usar `register-job-definition`.

**AWS CLI**  
**Para registrar uma definição de trabalho**  
Este exemplo registra uma definição de trabalho para um trabalho de contêiner simples.  
Comando:  

```
aws batch register-job-definition --job-definition-name sleep30 --type container --container-properties '{ "image": "busybox", "vcpus": 1, "memory": 128, "command": [ "sleep", "30"]}'
```
Resultado:  

```
{
    "jobDefinitionArn": "arn:aws:batch:us-east-1:012345678910:job-definition/sleep30:1",
    "jobDefinitionName": "sleep30",
    "revision": 1
}
```
+  Para ver detalhes da API, consulte [RegisterJobDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/register-job-definition.html) na *Referência de comandos da AWS CLI*. 

### `submit-job`
<a name="batch_SubmitJob_cli_topic"></a>

O código de exemplo a seguir mostra como usar `submit-job`.

**AWS CLI**  
**Como enviar um trabalho**  
Este exemplo envia um trabalho de contêiner simples chamado example para a fila de trabalhos HighPriority.  
Comando:  

```
aws batch submit-job --job-name example --job-queue HighPriority  --job-definition sleep60
```
Resultado:  

```
{
    "jobName": "example",
    "jobId": "876da822-4198-45f2-a252-6cea32512ea8"
}
```
+  Para ver detalhes da API, consulte [SubmitJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/submit-job.html) na *Referência de comandos da AWS CLI*. 

### `terminate-job`
<a name="batch_TerminateJob_cli_topic"></a>

O código de exemplo a seguir mostra como usar `terminate-job`.

**AWS CLI**  
**Como encerrar um trabalho**  
Este exemplo encerra um trabalho com o ID de trabalho especificado.  
Comando:  

```
aws batch terminate-job --job-id 61e743ed-35e4-48da-b2de-5c8333821c84 --reason "Terminating job."
```
+  Para ver detalhes da API, consulte [TerminateJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/terminate-job.html) na *Referência de comandos da AWS CLI*. 

### `update-compute-environment`
<a name="batch_UpdateComputeEnvironment_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-compute-environment`.

**AWS CLI**  
**Para atualizar um ambiente de computação**  
Este exemplo desabilita o ambiente de computação P2OnDemand para que ele possa ser excluído.  
Comando:  

```
aws batch update-compute-environment --compute-environment P2OnDemand --state DISABLED
```
Resultado:  

```
{
    "computeEnvironmentName": "P2OnDemand",
    "computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/P2OnDemand"
}
```
+  Para ver detalhes da API, consulte [UpdateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-compute-environment.html) na *Referência de comandos da AWS CLI*. 

### `update-job-queue`
<a name="batch_UpdateJobQueue_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-job-queue`.

**AWS CLI**  
**Para atualizar uma fila de trabalhos**  
Este exemplo desabilita uma fila de trabalhos para que ela possa ser excluída.  
Comando:  

```
aws batch update-job-queue --job-queue GPGPU --state DISABLED
```
Resultado:  

```
{
    "jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/GPGPU",
    "jobQueueName": "GPGPU"
}
```
+  Para ver detalhes da API, consulte [UpdateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-job-queue.html) na *Referência de comandos da AWS CLI*.