

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Começando a usar AWS Batch a SageMaker IA
<a name="getting-started-sagemaker"></a>

AWS Batch os trabalhos de serviço permitem que você envie trabalhos de SageMaker treinamento por meio de filas de AWS Batch trabalhos com recursos de agendamento, priorização e enfileiramento. Este tutorial demonstra como configurar e executar um trabalho de SageMaker treinamento simples usando trabalhos AWS Batch de serviço.

**Contents**
+ [Visão geral do](#getting-started-sagemaker-context)
+ [Pré-requisitos](#getting-started-sagemaker-prerequisites)
+ [Etapa 1: criar uma função de execução de SageMaker IA](#getting-started-sagemaker-step-1)
+ [Etapa 2: criar seu ambiente de serviço](#getting-started-sagemaker-step-2)
+ [Etapa 3: Crie sua fila SageMaker de trabalhos](#getting-started-sagemaker-step-3)
+ [Etapa 4: criar e enviar uma tarefa de treinamento](#getting-started-sagemaker-step-4)
+ [Etapa 5: monitorar o status do trabalho](#getting-started-sagemaker-step-5)
+ [Etapa 6: ver a saída do trabalho](#getting-started-sagemaker-step-6)
+ [Etapa 7: limpar os recursos do tutorial](#getting-started-sagemaker-step-7)
+ [Recursos adicionais do](#getting-started-sagemaker-additional-resources)

## Visão geral do
<a name="getting-started-sagemaker-context"></a>

Este tutorial demonstra como configurar trabalhos de AWS Batch serviço para trabalhos SageMaker de treinamento usando o. AWS CLI

**Público-alvo**  
Este tutorial foi desenvolvido para cientistas de dados e desenvolvedores responsáveis por configurar e executar trabalhos de treinamento de machine learning em grande escala.

**Características usadas**  
Este tutorial mostra como usar o AWS CLI para:  
+ Crie um ambiente de serviço para trabalhos SageMaker de treinamento
+ Crie uma fila SageMaker de trabalhos de treinamento
+ Enviar trabalhos de serviço usando a API `SubmitServiceJob`
+ Monitorar o status do trabalho e visualizar os resultados
+  CloudWatch Registros de acesso para trabalhos de treinamento

**Tempo necessário**  
Ele levará aproximadamente 15 minutos para ser concluído.

**Restrições regionais**  
Este tutorial pode ser concluído em qualquer AWS região em que tanto a IA AWS Batch quanto a SageMaker IA estejam disponíveis.

**Custos de uso de recursos**  
Não há cobrança pela criação de uma AWS conta. No entanto, ao implementar essa solução, pode haver custos para os seguintes recursos:      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/batch/latest/userguide/getting-started-sagemaker.html)

## Pré-requisitos
<a name="getting-started-sagemaker-prerequisites"></a>

Antes de iniciar este tutorial, você deve instalar e configurar as seguintes ferramentas e recursos necessários para criar e gerenciar tanto os recursos de IA AWS Batch quanto os recursos de SageMaker IA.
+ **AWS CLI**— Uma ferramenta de linha de comando para trabalhar com AWS serviços, incluindo AWS Batch SageMaker IA. Este guia exige que você use a versão 2.8.6 ou posterior. Para obter mais informações, consulte [Como instalar, atualizar e desinstalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) no *Guia do usuário da AWS Command Line Interface *. Depois de instalar o AWS CLI, recomendamos que você também o configure. Para obter mais informações, consulte [Configuração rápida com o `aws configure`](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) no *Manual do usuário do AWS Command Line Interface *.

## Etapa 1: criar uma função de execução de SageMaker IA
<a name="getting-started-sagemaker-step-1"></a>

SageMaker A IA usa funções de execução para realizar operações em seu nome usando outros AWS serviços. Você deve criar uma função de execução e conceder permissões de SageMaker IA para usar os serviços e recursos necessários para trabalhos de treinamento. Use a política gerenciada `AmazonSageMakerFullAccess`, pois ela inclui permissões para o Amazon S3. 

**nota**  
Use as instruções a seguir para criar a função de execução de SageMaker IA para este tutorial.  
Antes de criar uma função de execução para seu ambiente de produção, recomendamos que você analise [Como usar funções de execução de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) no *[guia do desenvolvedor de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)*.

1. 

**Crie o perfil do IAM.**

   Crie um arquivo JSON chamado `sagemaker-trust-policy.json` com a política de confiança a seguir:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": "sagemaker.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

   Crie um perfil do IAM usando a política de confiança:

   ```
   aws iam create-role \
       --role-name SageMakerExecutionRole \
       --assume-role-policy-document file://sagemaker-trust-policy.json \
       --description "Execution role for SageMaker training jobs"
   ```

1. 

**Anexar políticas gerenciadas**

   Anexe as políticas do IAM gerenciadas necessárias ao perfil:

   ```
   aws iam attach-role-policy \
       --role-name SageMakerExecutionRole \
       --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
   ```

   ```
   aws iam attach-role-policy \
       --role-name SageMakerExecutionRole \
       --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
   ```

1. 

**Anotar o perfil de ARN**

   Obtenha o ARN do perfil, que você precisará em etapas posteriores:

   ```
   aws iam get-role --role-name SageMakerExecutionRole --query 'Role.Arn' --output text
   ```

   Salve esse ARN da forma como ele será usado ao criar sua carga útil de tarefa de treinamento.

## Etapa 2: criar seu ambiente de serviço
<a name="getting-started-sagemaker-step-2"></a>

Um ambiente de serviço define as restrições de capacidade para trabalhos de SageMaker treinamento. O ambiente de serviço encapsula o número máximo de instâncias de treinamento que podem ser executadas simultaneamente.

**Importante**  
Quando você cria seu primeiro ambiente de serviço para SageMaker treinamento, cria AWS Batch automaticamente uma função vinculada ao serviço chamada `AWSServiceRoleForAWSBatchWithSagemaker` em sua conta. Essa função permite AWS Batch enfileirar e gerenciar trabalhos SageMaker de treinamento em seu nome. Para obter mais informações sobre este perfil vinculado ao serviço e suas permissões, consulte [Usando funções para AWS Batch com SageMaker IA](using-service-linked-roles-batch-sagemaker.md).

Crie um ambiente de serviço que possa lidar com até 5 instâncias:

```
aws batch create-service-environment \
    --service-environment-name TutorialServiceEnvironment \
    --service-environment-type SAGEMAKER_TRAINING \
    --capacity-limits capacityUnit=NUM_INSTANCES,maxCapacity=5
```

Saída:

```
{
    "serviceEnvironmentName": "TutorialServiceEnvironment",
    "serviceEnvironmentArn": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment"
}
```

Verifique se o ambiente de serviço foi criado com sucesso:

```
aws batch describe-service-environments --service-environments TutorialServiceEnvironment
```

Saída:

```
{
    "serviceEnvironments": [
        {
            "serviceEnvironmentName": "TutorialServiceEnvironment",
            "serviceEnvironmentArn": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment",
            "serviceEnvironmentType": "SAGEMAKER_TRAINING",
            "state": "ENABLED",
            "status": "VALID",
            "capacityLimits": [
                {
                    "maxCapacity": 5,
                    "capacityUnit": "NUM_INSTANCES"
                }
            ],
            "tags": {}
        }
    ]
}
```

Para ter mais informações sobre ambientes de serviço, consulte [Ambientes de serviço para AWS Batch](service-environments.md).

## Etapa 3: Crie sua fila SageMaker de trabalhos
<a name="getting-started-sagemaker-step-3"></a>

Uma fila de SageMaker trabalhos gerencia o agendamento e a execução dos trabalhos de serviço. Os trabalhos enviados para essa fila serão enviados para seu ambiente de serviço com base na capacidade disponível.

Crie uma fila SageMaker de trabalhos de treinamento:

```
aws batch create-job-queue \
    --job-queue-name my-sm-training-fifo-jq \
    --job-queue-type SAGEMAKER_TRAINING \
    --priority 1 \
    --service-environment-order order=1,serviceEnvironment=TutorialServiceEnvironment
```

Saída:

```
{
    "jobQueueName": "my-sm-training-fifo-jq",
    "jobQueueArn": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq"
}
```

Verifique se a sua fila de trabalhos foi criada com sucesso:

```
aws batch describe-job-queues --job-queues my-sm-training-fifo-jq
```

Saída:

```
{
    "jobQueues": [
        {
            "jobQueueName": "my-sm-training-fifo-jq",
            "jobQueueArn": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq",
            "state": "ENABLED",
            "status": "VALID",
            "statusReason": "JobQueue Healthy",
            "priority": 1,
            "computeEnvironmentOrder": [],
            "serviceEnvironmentOrder": [
                {
                    "order": 1,
                    "serviceEnvironment": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment"
                }
            ],
            "jobQueueType": "SAGEMAKER_TRAINING",
            "tags": {}
        }
    ]
}
```

Para obter mais informações sobre filas de SageMaker trabalhos, consulte[Criar uma fila de trabalhos do SageMaker Training no AWS Batch](create-sagemaker-job-queue.md).

## Etapa 4: criar e enviar uma tarefa de treinamento
<a name="getting-started-sagemaker-step-4"></a>

Agora você criará uma tarefa de treinamento simples e a enviará para sua fila de trabalhos. Este exemplo usa uma tarefa de treinamento básica do tipo “hello world” que demonstra a funcionalidade do trabalho de serviço.

Crie um arquivo chamado `my_training_job.json` com o conteúdo a seguir. *your-account-id*Substitua pelo ID AWS da sua conta:

**nota**  
`S3OutputPath`é necessário para criar o trabalho de SageMaker treinamento, mas os resultados deste tutorial não são armazenados no bucket do Amazon S3 e você pode usar o caminho no seguinte JSON. Em seu ambiente de produção, você precisará de um bucket Amazon S3 válido para armazenar a saída, se quiser.

```
{
    "TrainingJobName": "my-simple-training-job",
    "RoleArn": "arn:aws:iam::your-account-id:role/SageMakerExecutionRole",
    "AlgorithmSpecification": {
        "TrainingInputMode": "File",
        "TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-training:2.0.0-cpu-py310",
        "ContainerEntrypoint": [
            "echo",
            "hello world"
        ]
    },
    "ResourceConfig": {
        "InstanceType": "ml.c5.xlarge",
        "InstanceCount": 1,
        "VolumeSizeInGB": 1
    },
    "OutputDataConfig": {
        "S3OutputPath": "s3://your-s3-bucket/output"
    },
    "StoppingCondition": {
        "MaxRuntimeInSeconds": 30
    }
}
```

Envie o trabalho de treinamento usando a [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)API:

```
aws batch submit-service-job \
    --job-queue my-sm-training-fifo-jq \
    --job-name my-batch-sm-job \
    --service-job-type SAGEMAKER_TRAINING \
    --retry-strategy attempts=1 \
    --timeout-config attemptDurationSeconds=60 \
    --service-request-payload file://my_training_job.json
```

Saída:

```
{
    "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
    "jobName": "my-batch-sm-job",
    "jobId": "your-job-id"
}
```

Para obter mais informações sobre cargas úteis de trabalho de serviço, consulte [Cargas úteis de trabalho de serviço em AWS Batch](service-job-payload.md). Para obter mais informações sobre como enviar trabalhos de serviço, consulte [Envie um trabalho de serviço em AWS Batch](service-job-submit.md).

## Etapa 5: monitorar o status do trabalho
<a name="getting-started-sagemaker-step-5"></a>

Você pode monitorar seus trabalhos de treinamento usando o seguinte AWS Batch APIs: [DescribeServiceJob[ListServiceJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_ListServiceJobs.html)](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeServiceJob.html), [GetJobQueueSnapshot](https://docs.aws.amazon.com/batch/latest/APIReference/API_GetJobQueueSnapshot.html)e. Esta seção mostra maneiras diferentes de verificar o status do trabalho e as informações da fila.

Veja os trabalhos em execução na sua fila:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq --job-status RUNNING
```

Saída:

```
{
    "jobSummaryList": [
        {
            "latestAttempt": {
                "serviceResourceId": {
                    "name": "TrainingJobArn",
                    "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
                }
            },
            "createdAt": 1753718760,
            "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
            "jobId": "your-job-id",
            "jobName": "my-batch-sm-job",
            "serviceJobType": "SAGEMAKER_TRAINING",
            "status": "RUNNING",
            "startedAt": 1753718820
        }
    ]
}
```

Veja os trabalhos que estão no estado `RUNNABLE`:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq --job-status RUNNABLE
```

Tenha uma visão geral dos próximos trabalhos em sua fila:

```
aws batch get-job-queue-snapshot --job-queue my-sm-training-fifo-jq
```

Saída:

```
{
    "frontOfQueue": {
        "jobs": [
            {
                "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
                "earliestTimeAtPosition": 1753718880
            },
            {
                "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id-2",
                "earliestTimeAtPosition": 1753718940
            }
        ],
        "lastUpdatedAt": 1753718970
    }
}
```

Pesquise os trabalhos por nome:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq \
    --filters name=JOB_NAME,values="my-batch-sm-job"
```

Saída:

```
{
    "jobSummaryList": [
        {
            "latestAttempt": {
                "serviceResourceId": {
                    "name": "TrainingJobArn",
                    "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
                }
            },
            "createdAt": 1753718760,
            "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
            "jobId": "your-job-id",
            "jobName": "my-batch-sm-job",
            "serviceJobType": "SAGEMAKER_TRAINING",
            "status": "RUNNING"
        }
    ]
}
```

Para obter mais informações sobre o mapeamento de estado de trabalho, consulte [Mapeando AWS Batch o status do trabalho do serviço para o status de SageMaker IA](service-job-status.md).

## Etapa 6: ver a saída do trabalho
<a name="getting-started-sagemaker-step-6"></a>

Depois que seu trabalho for concluído, você poderá visualizar a saída e os registros por meio da SageMaker IA APIs. AWS Batch 

Obtenha informações detalhadas sobre seu trabalho em AWS Batch:

```
aws batch describe-service-job \
    --job-id your-job-id
```

Saída:

```
{
    "attempts": [
        {
            "serviceResourceId": {
                "name": "TrainingJobArn",
                "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
            },
            "startedAt": 1753718820,
            "stoppedAt": 1753718880,
            "statusReason": "Received status from SageMaker: Training job completed"
        }
    ],
    "createdAt": 1753718760,
    "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
    "jobId": "your-job-id",
    "jobName": "my-batch-sm-job",
    "jobQueue": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq",
    "latestAttempt": {
        "serviceResourceId": {
            "name": "TrainingJobArn",
            "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
        }
    },
    "retryStrategy": {
        "attempts": 1,
        "evaluateOnExit": []
    },
    "serviceRequestPayload": "your-training-job-request-json",
    "serviceJobType": "SAGEMAKER_TRAINING",
    "startedAt": 1753718820,
    "status": "SUCCEEDED",
    "statusReason": "Received status from SageMaker: Training job completed",
    "stoppedAt": 1753718880,
    "tags": {},
    "timeoutConfig": {
        "attemptDurationSeconds": 60
    }
}
```

Esse comando retorna informações abrangentes do trabalho, incluindo o ARN do trabalho de SageMaker treinamento, que você pode usar para acessar o trabalho diretamente por meio SageMaker da IA:

```
aws sagemaker describe-training-job \
    --training-job-name AWSBatch<my-simple-training-job><your-attempt-id>
```

Para ver os CloudWatch registros do seu trabalho de treinamento, primeiro obtenha o nome do fluxo de registros:

```
aws logs describe-log-streams \
    --log-group-name /aws/sagemaker/TrainingJobs \
    --log-stream-name-prefix AWSBatchmy-simple-training-job
```

Saída:

```
{
    "logStreams": [
        {
            "logStreamName": "your-log-stream-name",
            "creationTime": 1753718830,
            "firstEventTimestamp": 1753718840,
            "lastEventTimestamp": 1753718850,
            "lastIngestionTime": 1753718860,
            "uploadSequenceToken": upload-sequence-token,
            "arn": "arn:aws:logs:your-region:your-account-id:log-group:/aws/sagemaker/TrainingJobs:log-stream:AWSBatch<my-simple-training-job><your-attempt-id>/algo-1-algo-id",
            "storedBytes": 0
        }
    ]
}
```

Em seguida, recupere os logs usando o nome do fluxo de log da resposta anterior:

```
aws logs get-log-events \
    --log-group-name /aws/sagemaker/TrainingJobs \
    --log-stream-name your-log-stream-name
```

Saída:

```
{
    "events": [
        {
            "timestamp": 1753718845,
            "message": "hello world",
            "ingestionTime": 1753718865
        }
    ],
    "nextForwardToken": "next-forward-token",
    "nextBackwardToken": "next-backward-token"
}
```

A saída do log mostra a mensagem “hello world” do da sua tarefa de treinamento, confirmando que a tarefa foi executada com sucesso.

## Etapa 7: limpar os recursos do tutorial
<a name="getting-started-sagemaker-step-7"></a>

Ao concluir este tutorial, limpe os recursos criados para evitar que causem cobranças.

Primeiro, desative e exclua a fila de trabalhos:

```
aws batch update-job-queue \
    --job-queue my-sm-training-fifo-jq \
    --state DISABLED
```

Aguarde até que a fila de trabalhos seja desativada e, em seguida, exclua-a:

```
aws batch delete-job-queue \
    --job-queue my-sm-training-fifo-jq
```

Em seguida, desative e exclua o ambiente de serviço:

```
aws batch update-service-environment \
    --service-environment TutorialServiceEnvironment \
    --state DISABLED
```

Aguarde até que o ambiente de serviço seja desativado e, em seguida, exclua-o:

```
aws batch delete-service-environment \
    --service-environment TutorialServiceEnvironment
```

## Recursos adicionais do
<a name="getting-started-sagemaker-additional-resources"></a>

Depois de concluir o tutorial, você pode querer explorar os seguintes tópicos:
+ Recomendamos usar o PySDK para a criação de trabalhos de serviço e envio para sua fila de trabalhos porque o PySDK tem classes auxiliares e utilitários. Para ver um exemplo de uso do PySDK, consulte exemplos de [SageMaker IA](https://github.com/aws/amazon-sagemaker-examples) em. GitHub
+ Saiba mais sobre [Empregos de serviços em AWS Batch](service-jobs.md).
+ Explore [Cargas úteis de trabalho de serviço em AWS Batch](service-job-payload.md) para configurações de tarefa de treinamento mais complexas.
+ Saiba mais sobre o [Envie um trabalho de serviço em AWS Batch](service-job-submit.md) e a API `SubmitServiceJob`.
+ Revise [Mapeando AWS Batch o status do trabalho do serviço para o status de SageMaker IA](service-job-status.md) para entender as transições de estado do trabalho.
+ Visite a [documentação do SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/) para ver formas mais completas de criar e enviar trabalhos de treinamento SageMaker usando Python.
+ Explore [SageMakerexemplos de notebooks](https://github.com/aws/amazon-sagemaker-examples) para fluxos de trabalho de aprendizado de máquina mais complexos.