

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á.

# Adapte o trabalho de treinamento para acessar as imagens em um registro privado do Docker
<a name="docker-containers-adapt-your-own-private-registry"></a>

Você pode usar um [registro privado do Docker](https://docs.docker.com/registry/) em vez de um Amazon Elastic Container Registry (Amazon ECR) para hospedar suas imagens para treinamento de IA. SageMaker As instruções a seguir mostram como criar um registro do Docker, configurar sua nuvem privada virtual (VPC) e seu trabalho de treinamento, armazenar imagens e SageMaker dar à IA acesso à imagem de treinamento no registro privado do docker. Essas instruções também mostram como usar um registro do Docker que requer autenticação para um trabalho de SageMaker treinamento.

## Criar e armazenar as imagens em um registro Docker privado
<a name="docker-containers-adapt-your-own-private-registry-prerequisites"></a>

Criar um registro Docker privado para armazenar as imagens. Seu registro deve:
+ usar o protocolo [API HTTP de registro do Docker](https://docs.docker.com/registry/spec/api/)
+ ser acessível a partir da mesma VPC especificada no [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)parâmetro na `CreateTrainingJob` API. Insira `VpcConfig` ao criar o trabalho de treinamento.
+ protegido com um [certificado TLS](https://aws.amazon.com/what-is/ssl-certificate/) de uma autoridade de certificação pública conhecida.

Para obter mais informações sobre como criar um registro do Docker, consulte [Como implantar um servidor de registro](https://docs.docker.com/registry/deploying/).

## Configure sua VPC e SageMaker seu trabalho de treinamento
<a name="docker-containers-adapt-your-own-private-registry-configure"></a>

SageMaker A IA usa uma conexão de rede em sua VPC para acessar imagens em seu registro do Docker. Para usar as imagens no registro do Docker para treinamento, o registro deve estar acessível em uma Amazon VPC na sua conta. Para obter mais informações, consulte [Use um registro do Docker que exija autenticação para treinamento](docker-containers-adapt-your-own-private-registry-authentication.md).

Você também deve configurar o trabalho de treinamento para se conectar à mesma VPC à qual seu registro do Docker tem acesso. Para obter mais informações, consulte [Configurar um trabalho de treinamento para acesso ao Amazon VPC ](https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html#train-vpc-configure).

## Crie um trabalho de treinamento usando uma imagem do seu registro privado do Docker
<a name="docker-containers-adapt-your-own-private-registry-create"></a>

Para usar uma imagem do seu registro privado do Docker para treinamento, use o guia a seguir para configurar a imagem, configurar e criar um trabalho de treinamento. Os exemplos de código a seguir usam o AWS SDK para Python (Boto3) cliente.

1. Crie um objeto de configuração de imagem de treinamento e insira `Vpc`, o campo `TrainingRepositoryAccessMode` da seguinte forma.

   ```
   training_image_config = {
       'TrainingRepositoryAccessMode': 'Vpc'
   }
   ```
**nota**  
Se seu registro privado do Docker exigir autenticação, você deverá adicionar um objeto `TrainingRepositoryAuthConfig` ao objeto de configuração da imagem de treinamento. Você também deve especificar o Amazon Resource Name (ARN) de uma AWS Lambda função que fornece credenciais de acesso à SageMaker IA usando o `TrainingRepositoryCredentialsProviderArn` campo do objeto. `TrainingRepositoryAuthConfig` Para obter mais informações, consulte a estrutura de código de exemplo a seguir.  

   ```
   training_image_config = {
      'TrainingRepositoryAccessMode': 'Vpc',
      'TrainingRepositoryAuthConfig': {
           'TrainingRepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName'
      }
   }
   ```

   Para obter informações sobre como criar a função do Lambda para fornecer autenticação, consulte [Use um registro do Docker que exija autenticação para treinamento](docker-containers-adapt-your-own-private-registry-authentication.md).

1. Use um cliente Boto3 para criar um trabalho de treinamento e passar a configuração correta para a API [create\$1training\$1job](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). As instruções a seguir mostram como configurar os componentes e criar um trabalho de treinamento.

   1. Crie o objeto `AlgorithmSpecification` que você deseja passar para `create_training_job`. Use o objeto de configuração da imagem de treinamento criado na etapa anterior, conforme exibido no seguinte exemplo de código.

      ```
      algorithm_specification = {
         'TrainingImage': 'myteam.myorg.com/docker-local/my-training-image:<IMAGE-TAG>',
         'TrainingImageConfig': training_image_config,
         'TrainingInputMode': 'File'
      }
      ```
**nota**  
Para usar uma versão fixa, em vez de uma versão atualizada de uma imagem, consulte o [resumo](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier) da imagem em vez de usar o nome ou a tag.

   1. Especifique o nome do trabalho de treinamento e da função para a qual deseja passar para `create_training_job`, conforme mostrado no seguinte exemplo de código. 

      ```
      training_job_name = 'private-registry-job'
      execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole'
      ```

   1. Especifique um grupo de segurança e uma sub-rede para a configuração da VPC para o trabalho de treinamento. Seu registro privado do Docker deve permitir o tráfego de entrada dos grupos de segurança que você especificar, conforme mostrado no exemplo de código a seguir.

      ```
      vpc_config = {
          'SecurityGroupIds': ['sg-0123456789abcdef0'],
          'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1']
      }
      ```
**nota**  
Se sua sub-rede não estiver na mesma VPC que seu registro privado do Docker, você deverá configurar uma conexão de rede entre as duas. VPCs SeeConnect VPCs usando o [peering de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) para obter mais informações.

   1. Especifique a configuração de recursos, incluindo instâncias de computação de machine learning e volumes de armazenamento a serem usados para treinamento, conforme mostrado no exemplo de código a seguir. 

      ```
      resource_config = {
          'InstanceType': 'ml.m4.xlarge',
          'InstanceCount': 1,
          'VolumeSizeInGB': 10,
      }
      ```

   1. Especifique a configuração dos dados de entrada e saída, onde o conjunto de dados de treinamento é armazenado e onde você deseja armazenar os artefatos do modelo, conforme mostrado no exemplo de código a seguir.

      ```
      input_data_config = [
          {
              "ChannelName": "training",
              "DataSource":
              {
                  "S3DataSource":
                  {
                      "S3DataDistributionType": "FullyReplicated",
                      "S3DataType": "S3Prefix",
                      "S3Uri": "s3://your-training-data-bucket/training-data-folder"
                  }
              }
          }
      ]
      
      output_data_config = {
          'S3OutputPath': 's3://your-output-data-bucket/model-folder'
      }
      ```

   1. Especifique o número máximo de segundos que um trabalho de treinamento de modelo pode ser executado, conforme mostrado no exemplo de código a seguir.

      ```
      stopping_condition = {
          'MaxRuntimeInSeconds': 1800
      }
      ```

   1. Por fim, crie o trabalho de treinamento usando os parâmetros especificados nas etapas anteriores, conforme exibido no seguinte exemplo de código.

      ```
      import boto3
      sm = boto3.client('sagemaker')
      try:
          resp = sm.create_training_job(
              TrainingJobName=training_job_name,
              AlgorithmSpecification=algorithm_specification,
              RoleArn=execution_role_arn,
              InputDataConfig=input_data_config,
              OutputDataConfig=output_data_config,
              ResourceConfig=resource_config,
              VpcConfig=vpc_config,
              StoppingCondition=stopping_condition
          )
      except Exception as e:
          print(f'error calling CreateTrainingJob operation: {e}')
      else:
          print(resp)
      ```

# Use um estimador de SageMaker IA para executar um trabalho de treinamento
<a name="docker-containers-adapt-your-own-private-registry-estimator"></a>

Você também pode usar um [estimador](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) do SDK do SageMaker Python para lidar com a configuração e a execução do seu trabalho de treinamento. SageMaker Os exemplos de código a seguir mostram como configurar e executar um estimador usando imagens de um registro particular do Docker.

1. Importe as bibliotecas e dependências necessárias, conforme exibido no seguinte exemplo de código.

   ```
   import boto3
   import sagemaker
   from sagemaker.estimator import Estimator
   
   session = sagemaker.Session()
   
   role = sagemaker.get_execution_role()
   ```

1. Forneça um Identificador de recursos uniforme (Uniform Resource Identifier, URI) para a imagem de treinamento, grupos de segurança e sub-redes para a configuração da VPC para o trabalho de treinamento, conforme mostrado no exemplo de código a seguir.

   ```
   image_uri = "myteam.myorg.com/docker-local/my-training-image:<IMAGE-TAG>"
   
   security_groups = ["sg-0123456789abcdef0"]
   subnets = ["subnet-0123456789abcdef0", "subnet-0123456789abcdef0"]
   ```

   Para obter mais informações sobre `security_group_ids` e`subnets`, consulte a descrição apropriada do parâmetro na seção [Estimadores](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) do SDK para Python SageMaker .
**nota**  
SageMaker A IA usa uma conexão de rede em sua VPC para acessar imagens em seu registro do Docker. Para usar as imagens no registro do Docker para treinamento, o registro deve estar acessível em uma Amazon VPC na sua conta.

1. Opcionalmente, se seu registro do Docker exigir autenticação, você também deverá especificar o Amazon Resource Name (ARN) de uma AWS Lambda função que fornece credenciais de acesso à IA. SageMaker O exemplo a seguir mostra como especificar o ARN. 

   ```
   training_repository_credentials_provider_arn = "arn:aws:lambda:us-west-2:1234567890:function:test"
   ```

   Para obter mais informações sobre o uso de imagens em um registro do Docker que exige autenticação, consulte abaixo **Usar um registro do Docker que exija autenticação para treinamento**.

1. Use os exemplos de código das etapas anteriores para configurar um estimador, conforme mostrado no exemplo de código a seguir.

   ```
   # The training repository access mode must be 'Vpc' for private docker registry jobs 
   training_repository_access_mode = "Vpc"
   
   # Specify the instance type, instance count you want to use
   instance_type="ml.m5.xlarge"
   instance_count=1
   
   # Specify the maximum number of seconds that a model training job can run
   max_run_time = 1800
   
   # Specify the output path for the model artifacts
   output_path = "s3://your-output-bucket/your-output-path"
   
   estimator = Estimator(
       image_uri=image_uri,
       role=role,
       subnets=subnets,
       security_group_ids=security_groups,
       training_repository_access_mode=training_repository_access_mode,
       training_repository_credentials_provider_arn=training_repository_credentials_provider_arn,  # remove this line if auth is not needed
       instance_type=instance_type,
       instance_count=instance_count,
       output_path=output_path,
       max_run=max_run_time
   )
   ```

1. Inicie o trabalho de treinamento chamando `estimator.fit` com o nome do trabalho e o caminho de entrada como parâmetros, conforme mostrado no seguinte exemplo de código.

   ```
   input_path = "s3://your-input-bucket/your-input-path"
   job_name = "your-job-name"
   
   estimator.fit(
       inputs=input_path,
       job_name=job_name
   )
   ```

# Use um registro do Docker que exija autenticação para treinamento
<a name="docker-containers-adapt-your-own-private-registry-authentication"></a>

Se seu registro do Docker exigir autenticação, você deverá criar uma AWS Lambda função que forneça credenciais de acesso à IA. SageMaker Em seguida, crie um trabalho de treinamento e forneça o ARN dessa função do Lambda dentro da API [create\$1training\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job). Por fim, você pode criar opcionalmente um Endpoint de interface da VPC para que sua VPC possa se comunicar com a função do Lambda sem enviar tráfego pela Internet. O guia a seguir mostra como criar uma função do Lambda, atribuir a ela a função correta e criar um Endpoint de interface da VPC.

## Criar a função do Lambda
<a name="docker-containers-adapt-your-own-private-registry-authentication-create-lambda"></a>

Crie uma AWS Lambda função que transmita as credenciais de acesso para a SageMaker IA e retorne uma resposta. O exemplo de código a seguir cria o manipulador da função do Lambda, da seguinte forma.

```
def handler(event, context):
   response = {
      "Credentials": {"Username": "username", "Password": "password"}
   }
   return response
```

O tipo de autenticação usado para configurar o registro privado do Docker determina o conteúdo da resposta retornada pela função do Lambda da seguinte forma.
+ Se seu registro privado do Docker usar autenticação básica, a função Lambda retornará o nome de usuário e a senha necessários para se autenticar no registro.
+ Se o seu registro privado do Docker usar a [autenticação do token do portador](https://docs.docker.com/registry/spec/auth/token/), o nome de usuário e a senha serão enviados ao seu servidor de autorização, que então retornará um token do portador. Esse token é então usado para se autenticar em seu registro privado do Docker.

**nota**  
Se você tiver mais de uma função do Lambda para seus registros na mesma conta e a função de execução for a mesma para seus trabalhos de treinamento, os trabalhos de treinamento para registro terão acesso às funções do Lambda para outros registros.

## Conceda as permissões de função corretas para a função do Lambda.
<a name="docker-containers-adapt-your-own-private-registry-authentication-lambda-role"></a>

O [IAMrole](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)que você usa na `create_training_job` API deve ter permissão para chamar uma AWS Lambda função. O exemplo de código a seguir mostra como estender uma política de permissões a uma função do IAM para chamar `myLambdaFunction`.

```
{
    "Effect": "Allow",
    "Action": [
        "lambda:InvokeFunction"
    ],
    "Resource": [
        "arn:aws:lambda:*:*:function:*myLambdaFunction*"
    ]
}
```

Para saber mais sobre como editar uma política de permissões de uma função, consulte [Modificar a política de permissões de uma função (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy), no *Guia do usuário do Gerenciamento de acesso do AWS *.

**nota**  
Uma função do IAM com uma política **AmazonSageMakerFullAccess**gerenciada anexada tem permissão para chamar qualquer função do Lambda com “SageMaker AI” em seu nome.

## Criar um Endpoint de interface da VPC para o Lambda
<a name="docker-containers-adapt-your-own-private-registry-authentication-lambda-endpoint"></a>

Se você criar um endpoint de interface, a Amazon VPC poderá se comunicar com a função do Lambda sem enviar tráfego pela Internet. Para obter mais informações, consulte [Configurar endpoints da VPC de interface para o Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) no *Guia do desenvolvedor AWS Lambda *.

Depois que seu endpoint de interface for criado, o SageMaker treinamento chamará sua função Lambda enviando uma solicitação por meio de sua VPC para. `lambda.region.amazonaws.com` Se você selecionar **Habilitar nome DNS** ao criar seu endpoint de interface, o [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) roteará a chamada para o endpoint da interface Lambda. Se você usar um provedor de DNS diferente, deverá relacionar o `lambda.region.amazonaws.co` ao endpoint da interface Lambda.