

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Adaptation de votre tâche d’entraînement pour accéder aux images dans un registre Docker privé
<a name="docker-containers-adapt-your-own-private-registry"></a>

Vous pouvez utiliser un [registre Docker](https://docs.docker.com/registry/) privé au lieu d'un Amazon Elastic Container Registry (Amazon ECR) pour héberger vos images pour AI Training. SageMaker Les instructions suivantes vous montrent comment créer un registre Docker, configurer votre cloud privé virtuel (VPC) et votre tâche de formation, stocker des images et SageMaker autoriser l'IA à accéder à l'image d'entraînement dans le registre Docker privé. Ces instructions vous montrent également comment utiliser un registre Docker qui nécessite une authentification pour une tâche de SageMaker formation.

## Création et stockage de vos images dans un registre Docker privé
<a name="docker-containers-adapt-your-own-private-registry-prerequisites"></a>

Créez un registre Docker privé pour stocker vos images. Votre registre doit :
+ utiliser le protocole [Docker Registry HTTP API](https://docs.docker.com/registry/spec/api/).
+ être accessible depuis le même VPC spécifié dans le [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)paramètre de l'API. `CreateTrainingJob` Entrez `VpcConfig` lorsque vous créez votre tâche d’entraînement.
+ être sécurisé à l’aide d’un [certificat TLS](https://aws.amazon.com/what-is/ssl-certificate/) provenant d’une autorité de certification (CA) publique connue.

Pour plus d’informations sur la création d’un registre Docker, consultez [Deploy a registry server](https://docs.docker.com/registry/deploying/).

## Configurez votre VPC et SageMaker votre tâche de formation
<a name="docker-containers-adapt-your-own-private-registry-configure"></a>

SageMaker L'IA utilise une connexion réseau au sein de votre VPC pour accéder aux images de votre registre Docker. Pour utiliser ces images dans votre registre Docker à des fins d’entraînement, le registre doit être accessible à partir d’un Amazon VPC dans votre compte. Pour de plus amples informations, veuillez consulter [Utilisation d’un registre Docker nécessitant une authentification pour l’entraînement](docker-containers-adapt-your-own-private-registry-authentication.md).

Vous devez également configurer votre tâche d’entraînement pour qu’elle se connecte au même VPC auquel votre registre Docker a accès. Pour plus d’informations, consultez [Configuration d’une tâche d’entraînement pour l’accès à Amazon VPC](https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html#train-vpc-configure).

## Création d’une tâche d’entraînement à l’aide d’une image provenant de votre registre Docker privé
<a name="docker-containers-adapt-your-own-private-registry-create"></a>

Pour utiliser une image provenant de votre registre Docker privé à des fins d’entraînement, utilisez le guide suivant pour configurer votre image, et configurer et créer une tâche d’entraînement. Les exemples de code suivants utilisent le AWS SDK pour Python (Boto3) client.

1. Créez un objet de configuration d’image d’entraînement et entrez `Vpc` dans le champ `TrainingRepositoryAccessMode` comme suit.

   ```
   training_image_config = {
       'TrainingRepositoryAccessMode': 'Vpc'
   }
   ```
**Note**  
Si votre registre Docker privé nécessite une authentification, vous devez ajouter un objet `TrainingRepositoryAuthConfig` à l’objet de configuration d’image d’entraînement. Vous devez également spécifier l'Amazon Resource Name (ARN) d'une AWS Lambda fonction qui fournit des informations d'accès à l' SageMaker IA à l'aide du `TrainingRepositoryCredentialsProviderArn` champ de l'`TrainingRepositoryAuthConfig`objet. Pour plus d’informations, consultez l’exemple de structure de code ci-dessous.  

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

   Pour plus d’informations sur la création de la fonction Lambda pour fournir une authentification, consultez [Utilisation d’un registre Docker nécessitant une authentification pour l’entraînement](docker-containers-adapt-your-own-private-registry-authentication.md).

1. Utilisez un client Boto3 pour créer une tâche d’entraînement et transmettre la configuration correcte à l’API [create\$1training\$1job](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Les instructions suivantes vous montrent comment configurer les composants et créer une tâche d’entraînement.

   1. Créez l’objet `AlgorithmSpecification` que vous souhaitez transmettre à `create_training_job`. Utilisez l’objet de configuration d’image d’entraînement que vous avez créé à l’étape précédente, comme illustré dans l’exemple de code suivant.

      ```
      algorithm_specification = {
         'TrainingImage': 'myteam.myorg.com/docker-local/my-training-image:<IMAGE-TAG>',
         'TrainingImageConfig': training_image_config,
         'TrainingInputMode': 'File'
      }
      ```
**Note**  
Pour utiliser une version fixe plutôt qu’une version mise à jour d’une image, reportez-vous au [résumé](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier) de l’image plutôt qu’à son nom ou son identification.

   1. Spécifiez le nom de la tâche d’entraînement et le rôle que vous souhaitez transmettre à `create_training_job`, comme illustré dans l’exemple de code suivant. 

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

   1. Spécifiez un groupe de sécurité et un sous-réseau dans la configuration du VPC pour votre tâche d’entraînement. Votre registre Docker privé doit autoriser le trafic entrant provenant des groupes de sécurité que vous spécifiez, comme illustré dans l’exemple de code suivant.

      ```
      vpc_config = {
          'SecurityGroupIds': ['sg-0123456789abcdef0'],
          'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1']
      }
      ```
**Note**  
Si votre sous-réseau ne se trouve pas dans le même VPC que votre registre Docker privé, vous devez configurer une connexion réseau entre les deux. VPCs SeeConnect VPCs en utilisant le [peering VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) pour plus d'informations.

   1. Spécifiez la configuration des ressources, y compris les instances de calcul de machine learning et les volumes de stockage à utiliser pour l’entraînement, comme indiqué dans l’exemple de code suivant. 

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

   1. Spécifiez la configuration des données d’entrée et de sortie, l’emplacement de stockage du jeu de données d’entraînement et l’emplacement où vous souhaitez stocker les artefacts de modèle, comme indiqué dans l’exemple de code suivant.

      ```
      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. Spécifiez le nombre maximal de secondes de l’exécution d’une tâche d’entraînement des modèles comme indiqué dans l’exemple de code suivant.

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

   1. Enfin, créez la tâche d’entraînement à l’aide des paramètres que vous avez spécifiés aux étapes précédentes, comme indiqué dans l’exemple de code suivant.

      ```
      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)
      ```

# Utiliser un estimateur basé sur l' SageMaker IA pour exécuter une tâche de formation
<a name="docker-containers-adapt-your-own-private-registry-estimator"></a>

Vous pouvez également utiliser un [estimateur](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) du SDK SageMaker Python pour gérer la configuration et l'exécution de votre SageMaker tâche de formation. Les exemples de code suivants montrent comment configurer et exécuter un estimateur à l’aide d’images provenant d’un registre Docker privé.

1. Importez les bibliothèques et dépendances requises, comme indiqué dans l’exemple de code suivant.

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

1. Fournissez un identifiant de ressource uniforme (URI) à votre image d’entraînement, à vos groupes de sécurité et à vos sous-réseaux dans la configuration du VPC pour votre tâche d’entraînement, comme indiqué dans l’exemple de code suivant.

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

   Pour plus d'informations sur `security_group_ids` et`subnets`, consultez la description des paramètres appropriés dans la section [Estimateurs](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) du SDK SageMaker Python.
**Note**  
SageMaker L'IA utilise une connexion réseau au sein de votre VPC pour accéder aux images de votre registre Docker. Pour utiliser ces images dans votre registre Docker à des fins d’entraînement, le registre doit être accessible à partir d’un Amazon VPC dans votre compte.

1. Facultativement, si votre registre Docker nécessite une authentification, vous devez également spécifier l'Amazon Resource Name (ARN) d'une AWS Lambda fonction qui fournit des informations d'accès à SageMaker AI. L’exemple de code suivant montre comment spécifier l’ARN. 

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

   Pour plus d’informations sur l’utilisation d’images dans un registre Docker nécessitant une authentification, consultez **Utilisation d’un registre Docker nécessitant une authentification pour l’entraînement** ci-dessous.

1. Utilisez les exemples de code des étapes précédentes pour configurer un estimateur, comme indiqué dans l’exemple de code suivant.

   ```
   # 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. Commencez votre tâche d’entraînement en appelant `estimator.fit` avec votre nom de tâche et le chemin d’entrée comme paramètres, comme indiqué dans l’exemple de code suivant.

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

# Utilisation d’un registre Docker nécessitant une authentification pour l’entraînement
<a name="docker-containers-adapt-your-own-private-registry-authentication"></a>

Si votre registre Docker nécessite une authentification, vous devez créer une AWS Lambda fonction fournissant des informations d'accès à l' SageMaker IA. Ensuite, créez une tâche d’entraînement et fournissez l’ARN de cette fonction Lambda dans l’API [create\$1training\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job). Enfin, vous pouvez éventuellement créer un point de terminaison de VPC d’interface pour que votre VPC puisse communiquer avec votre fonction Lambda sans envoyer le trafic sur Internet. Le guide suivant explique comment créer une fonction Lambda, lui attribuer le rôle approprié et créer un point de terminaison de VPC d’interface.

## Créer la fonction Lambda
<a name="docker-containers-adapt-your-own-private-registry-authentication-create-lambda"></a>

Créez une AWS Lambda fonction qui transmet les informations d'accès à l' SageMaker IA et renvoie une réponse. L’exemple de code suivant crée le gestionnaire de fonction Lambda, comme suit.

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

Le type d’authentification utilisé pour configurer votre registre Docker privé détermine le contenu de la réponse renvoyée par votre fonction Lambda comme suit.
+ Si votre registre Docker privé utilise une authentification de base, la fonction Lambda renverra le nom d’utilisateur et le mot de passe nécessaires pour s’authentifier auprès du registre.
+ Si votre registre Docker privé utilise l’[authentification par jeton du porteur](https://docs.docker.com/registry/spec/auth/token/), le nom d’utilisateur et le mot de passe sont envoyés à votre serveur d’autorisation, qui renvoie un jeton du porteur. Ce jeton est ensuite utilisé pour l’authentification auprès de votre registre Docker privé.

**Note**  
Si vous avez plusieurs fonctions Lambda pour vos registres dans le même compte et que le rôle d’exécution est le même pour vos tâches d’entraînement, les tâches d’entraînement pour le registre 1 auront accès aux fonctions Lambda pour les autres registres.

## Octroi de l’autorisation de rôle appropriée à votre fonction Lambda
<a name="docker-containers-adapt-your-own-private-registry-authentication-lambda-role"></a>

Le [IAMrole](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)que vous utilisez dans l'`create_training_job`API doit être autorisé à appeler une AWS Lambda fonction. L’exemple de code suivant montre comment étendre la politique d’autorisation d’un rôle IAM pour appeler `myLambdaFunction`.

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

Pour obtenir des informations sur la modification d’une politique d’autorisations de rôle, consultez [Modification d’une politique d’autorisations de rôle (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) dans le *Guide de l’utilisateur AWS Identity and Access Management*.

**Note**  
Un rôle IAM associé à une politique **AmazonSageMakerFullAccess**gérée est autorisé à appeler n'importe quelle fonction Lambda dont le nom contient SageMaker « AI ».

## Créer un point de terminaison de VPC d’interface pour Lambda
<a name="docker-containers-adapt-your-own-private-registry-authentication-lambda-endpoint"></a>

Si vous créez un point de terminaison d’interface, votre Amazon VPC peut communiquer avec votre fonction Lambda sans envoyer de trafic sur Internet. Pour plus d’informations, consultez [Configuration de points de terminaison de VPC d’interface pour Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) dans le *Guide du développeur AWS Lambda *.

Une fois le point de terminaison de votre interface créé, SageMaker Training appellera votre fonction Lambda en envoyant une demande via votre VPC à. `lambda.region.amazonaws.com` Si vous sélectionnez **Enable DNS Name** (Activer le nom DNS) lorsque vous créez votre point de terminaison d’interface, [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) route l’appel vers le point de terminaison d’interface Lambda. Si vous utilisez un fournisseur DNS différent, vous devez mapper `lambda.region.amazonaws.co`m à votre point de terminaison d’interface Lambda.