

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Passen Sie Ihren Trainingsauftrag so an, dass Sie auf Images in einer privaten Docker-Registry zugreifen können
<a name="docker-containers-adapt-your-own-private-registry"></a>

Sie können eine private [Docker-Registry](https://docs.docker.com/registry/) anstelle einer Amazon Elastic Container Registry (Amazon ECR) verwenden, um Ihre Images für SageMaker AI Training zu hosten. Die folgenden Anweisungen zeigen Ihnen, wie Sie eine Docker-Registry erstellen, Ihre Virtual Private Cloud (VPC) und Ihren Trainingsjob konfigurieren, Images speichern und SageMaker KI Zugriff auf das Trainings-Image in der privaten Docker-Registry gewähren. Diese Anweisungen zeigen Ihnen auch, wie Sie eine Docker-Registry verwenden, für die eine Authentifizierung für einen Trainingsjob erforderlich ist. SageMaker 

## Erstellen und Speichern Ihrer Images in einer privaten Docker-Registry
<a name="docker-containers-adapt-your-own-private-registry-prerequisites"></a>

Erstellen Sie eine private Docker-Registry, um Ihre Images zu speichern. Ihre Registry muss:
+ das Protokoll [Docker Registry HTTP API](https://docs.docker.com/registry/spec/api/) verwenden
+ von derselben VPC aus zugänglich sein, die im [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)Parameter in der `CreateTrainingJob` API angegeben ist. Geben Sie `VpcConfig` ein, wenn Sie Ihren Trainingsauftrag erstellen.
+ gesichert mit einem [TLS-Zertifikat](https://aws.amazon.com/what-is/ssl-certificate/) einer bekannten öffentlichen Zertifizierungsstelle.

Weitere Informationen zum Erstellen einer Docker-Registry finden Sie unter [Bereitstellen eines Registry-Servers](https://docs.docker.com/registry/deploying/).

## Konfigurieren Sie Ihre VPC und Ihren SageMaker Trainingsjob
<a name="docker-containers-adapt-your-own-private-registry-configure"></a>

SageMaker KI verwendet eine Netzwerkverbindung innerhalb Ihrer VPC, um auf Images in Ihrer Docker-Registry zuzugreifen. Um die Images in Ihrer Docker-Registry für Training zu verwenden, muss das Verzeichnis von einer Amazon-VPC in Ihrem Konto aus zugänglich sein. Weitere Informationen finden Sie unter [Verwenden Sie eine Docker-Registry, für die eine Authentifizierung für das Training erforderlich ist](docker-containers-adapt-your-own-private-registry-authentication.md).

Sie müssen Ihren Trainingsauftrag auch so konfigurieren, dass er eine Verbindung zu derselben VPC herstellt, auf die Ihre Docker-Registry Zugriff hat. Weitere Informationen finden Sie unter [Einen Trainingsauftrag für Amazon VPC Access konfigurieren](https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html#train-vpc-configure).

## Erstellen Sie einen Trainingsauftrag mit einem Image aus Ihrer privaten Docker-Registry
<a name="docker-containers-adapt-your-own-private-registry-create"></a>

Um ein Image aus Ihrer privaten Docker-Registry für Training zu verwenden, folgen Sie der folgenden Anleitung, um Ihr Image zu konfigurieren, und einen Trainingsauftrag zu konfigurieren und erstellen. In den folgenden Codebeispielen wird der AWS SDK für Python (Boto3) Client verwendet.

1. Erstellen Sie ein Trainings-Image-Konfigurationsobjekt und geben Sie `Vpc` in das `TrainingRepositoryAccessMode` Feld wie folgt ein.

   ```
   training_image_config = {
       'TrainingRepositoryAccessMode': 'Vpc'
   }
   ```
**Anmerkung**  
Wenn Ihre private Docker-Registry eine Authentifizierung erfordert, müssen Sie dem Trainings-Image-Konfigurationsobjekt ein `TrainingRepositoryAuthConfig` Objekt hinzufügen. Sie müssen auch den Amazon-Ressourcennamen (ARN) einer AWS Lambda Funktion angeben, die mithilfe des `TrainingRepositoryCredentialsProviderArn` Felds des `TrainingRepositoryAuthConfig` Objekts Zugangsdaten für SageMaker KI bereitstellt. Weitere Informationen finden Sie in der nachstehenden Beispiel-Code-Struktur.  

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

   Weitere Informationen zum Erstellen der Lambda-Funktion für die Authentifizierung finden Sie unter [Verwenden Sie eine Docker-Registry, für die eine Authentifizierung für das Training erforderlich ist](docker-containers-adapt-your-own-private-registry-authentication.md).

1. Verwenden Sie einen Boto3-Client, um einen Trainingsauftrag zu erstellen und die richtige Konfiguration an die [create\$1training\$1job](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)-API zu übergeben. Die folgenden Anweisungen zeigen Ihnen, wie Sie die Komponenten konfigurieren und einen Trainingsauftrag erstellen.

   1. Erstellen Sie das `AlgorithmSpecification` Objekt, das Sie an `create_training_job` senden möchten. Verwenden Sie das Trainings-Image-Konfigurationsobjekt, das Sie im vorherigen Schritt erstellt haben, wie im folgenden Codebeispiel gezeigt.

      ```
      algorithm_specification = {
         'TrainingImage': 'myteam.myorg.com/docker-local/my-training-image:<IMAGE-TAG>',
         'TrainingImageConfig': training_image_config,
         'TrainingInputMode': 'File'
      }
      ```
**Anmerkung**  
Wenn Sie statt einer aktualisierten Version eines Images eine feste Version verwenden möchten, beziehen Sie sich auf den [Digest](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier) des Images und nicht auf den Namen oder das Tag.

   1. Geben Sie den Namen des Trainingsauftrags und der Rolle an, den Sie an `create_training_job` senden möchten, wie im folgenden Codebeispiel gezeigt. 

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

   1. Geben Sie eine Sicherheitsgruppe und ein Subnetz für die VPC-Konfiguration für Ihren Trainingsauftrag an. Ihre private Docker-Registry muss eingehenden Datenverkehr von den von Ihnen angegebenen Sicherheitsgruppen zulassen, wie im folgenden Codebeispiel gezeigt.

      ```
      vpc_config = {
          'SecurityGroupIds': ['sg-0123456789abcdef0'],
          'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1']
      }
      ```
**Anmerkung**  
Wenn sich Ihr Subnetz nicht in derselben VPC wie Ihre private Docker-Registry befindet, müssen Sie eine Netzwerkverbindung zwischen den beiden einrichten. VPCs SeeConnect VPCs Verwenden Sie [VPC-Peering](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) für weitere Informationen.

   1. Geben Sie die Ressourcenkonfiguration an, einschließlich Rechen-Instances für Machine Learning und Speichervolumes, die für das Training verwendet werden sollen, wie im folgenden Codebeispiel gezeigt. 

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

   1. Geben Sie die Konfiguration der Eingabe- und Ausgabedaten an, wo der Trainingsdatensatz gespeichert wird und wo Sie Modellartefakte speichern möchten, wie im folgenden Codebeispiel gezeigt.

      ```
      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. Geben Sie die maximale Anzahl von Sekunden an, für die ein Modelltrainingsauftrag ausgeführt werden kann, wie im folgenden Codebeispiel gezeigt.

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

   1. Erstellen Sie abschließend den Trainingsauftrag mit den Parametern, die Sie in den vorherigen Schritten angegeben haben, wie im folgenden Codebeispiel gezeigt.

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

# Verwenden Sie einen SageMaker KI-Schätzer, um einen Trainingsjob auszuführen
<a name="docker-containers-adapt-your-own-private-registry-estimator"></a>

Sie können auch einen [Schätzer](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) aus dem SageMaker Python-SDK verwenden, um die Konfiguration und Ausführung Ihres SageMaker Trainingsjobs zu übernehmen. In den folgenden Codebeispielen wird gezeigt, wie ein Schätzer mithilfe von Images aus einer privaten Docker-Registry konfiguriert und ausführt wird.

1. Importieren Sie die erforderlichen Bibliotheken und Abhängigkeiten wie im folgenden Codebeispiel:

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

1. Geben Sie einen Uniform Resource Identifier (URI) für Ihr Trainings-Image, Ihre Sicherheitsgruppen und Subnetze für die VPC-Konfiguration für Ihren Trainingsauftrag ein, wie im folgenden Codebeispiel gezeigt.

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

   Weitere Informationen zu `security_group_ids` und `subnets` finden Sie in der entsprechenden Parameterbeschreibung im Abschnitt [Estimators](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) des SageMaker Python-SDK.
**Anmerkung**  
SageMaker KI verwendet eine Netzwerkverbindung innerhalb Ihrer VPC, um auf Images in Ihrer Docker-Registry zuzugreifen. Um die Images in Ihrer Docker-Registry für Training zu verwenden, muss das Verzeichnis von einer Amazon-VPC in Ihrem Konto aus zugänglich sein.

1. Wenn Ihre Docker-Registry eine Authentifizierung erfordert, müssen Sie optional auch den Amazon-Ressourcennamen (ARN) einer AWS Lambda Funktion angeben, die Zugangsdaten für SageMaker KI bereitstellt. Das folgende Codebeispiel zeigt, wie der ARN anzugeben ist. 

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

   Weitere Informationen zur Verwendung von Images in einer Docker-Registry, für die eine Authentifizierung erforderlich ist, finden Sie weiter unten unter **Verwenden einer Docker-Registry, für die eine Authentifizierung erforderlich ist**.

1. Verwenden Sie die Codebeispiele aus den vorherigen Schritten, um einen Schätzer zu konfigurieren, wie im folgenden Codebeispiel gezeigt.

   ```
   # 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. Starten Sie Ihren Trainingsauftrag, indem Sie `estimator.fit` mit Ihrem Auftragsnamen und Eingabepfad als Parameter aufrufen, wie im folgenden Codebeispiel gezeigt.

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

# Verwenden Sie eine Docker-Registry, für die eine Authentifizierung für das Training erforderlich ist
<a name="docker-containers-adapt-your-own-private-registry-authentication"></a>

Wenn Ihre Docker-Registry eine Authentifizierung erfordert, müssen Sie eine AWS Lambda Funktion erstellen, die Zugangsdaten für KI bereitstellt. SageMaker Erstellen Sie dann einen Trainingsauftrag und geben Sie den ARN dieser Lambda-Funktion in der [create\$1training\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)-API an. Schließlich können Sie optional einen VPC-Schnittstellen-Endpunkt erstellen, sodass Ihre VPC mit Ihrer Lambda-Funktion kommunizieren kann, ohne Datenverkehr über das Internet zu senden. Die folgende Anleitung zeigt, wie Sie eine Lambda-Funktion erstellen, ihr die richtige Rolle zuweisen und einen Schnittstellen-VPC-Endpunkt erstellen.

## So erstellen Sie die Lambda-Funktion:
<a name="docker-containers-adapt-your-own-private-registry-authentication-create-lambda"></a>

Erstellen Sie eine AWS Lambda Funktion, die Zugangsdaten an SageMaker KI weitergibt und eine Antwort zurückgibt. Im folgenden Codebeispiel wird der Lambda-Funktionshandler wie folgt erstellt.

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

Die Art der Authentifizierung, die zum Einrichten Ihrer privaten Docker-Registry verwendet wird, bestimmt den Inhalt der Antwort, die von Ihrer Lambda-Funktion zurückgegeben wird, wie folgt.
+ Wenn Ihre private Docker-Registry die Standardauthentifizierung verwendet, gibt die Lambda-Funktion den Benutzernamen und das Passwort zurück, die für die Authentifizierung bei der Registrierung erforderlich sind.
+ Wenn Ihre private Docker-Registry die [Bearer-Token-Authentifizierung](https://docs.docker.com/registry/spec/auth/token/) verwendet, werden der Benutzername und das Passwort an Ihren Autorisierungsserver gesendet, der dann ein Bearer-Token zurückgibt. Dieses Token wird dann zur Authentifizierung bei Ihrer privaten Docker-Registry verwendet.

**Anmerkung**  
Wenn Sie mehr als eine Lambda-Funktion für Ihre Verzeichnisse in demselben Konto haben und die Ausführungsrolle für Ihre Trainingsaufträge dieselbe ist, dann hätten Trainingsaufträge für Registry One Zugriff auf die Lambda-Funktionen für andere Verzeichnisse.

## Gewähren Sie der Lambda-Funktion die korrekte Rolle.
<a name="docker-containers-adapt-your-own-private-registry-authentication-lambda-role"></a>

Die [IAMrole](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html), die Sie in der `create_training_job` API verwenden, muss über die Berechtigung zum Aufrufen einer AWS Lambda Funktion verfügen. Das folgende Codebeispiel zeigt, wie die Berechtigungsrichtlinie einer IAM-Rolle erweitert werden kann, um `myLambdaFunction` aufzurufen.

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

Weitere Informationen zum Bearbeiten von Rollenberechtigungsrichtlinien finden Sie unter [Modifizierung einer Rollenberechtigungsrichtline (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) in dem *AWS Benutzerhandbuch für Identitäts- und Zugriffsmanagement*.

**Anmerkung**  
Eine IAM-Rolle mit einer angehängten **AmazonSageMakerFullAccess**verwalteten Richtlinie ist berechtigt, jede Lambda-Funktion aufzurufen, deren Name „SageMaker AI“ enthält.

## So erstellen Sie einen Schnittstellen-VPC-Endpunkt für Lambda
<a name="docker-containers-adapt-your-own-private-registry-authentication-lambda-endpoint"></a>

Wenn Sie einen Schnittstellenendpunkt erstellen, kann Ihre Amazon VPC mit Ihrer Lambda-Funktion kommunizieren, ohne Datenverkehr über das Internet zu senden. Weitere Informationen finden Sie unter[Konfigurieren von Schnittstellen-VPC-Endpunkten für Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html)im*AWS Lambda Entwicklerhandbuch*.

Nachdem Ihr Schnittstellenendpunkt erstellt wurde, ruft das SageMaker Training Ihre Lambda-Funktion auf, indem eine Anfrage über Ihre VPC an gesendet wird. `lambda.region.amazonaws.com` Wenn Sie bei der Erstellung Ihres Schnittstellenendpunkts die Option **DNS-Name aktivieren** auswählen, leitet [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) den Anruf an den Lambda-Schnittstellenendpunkt weiter. Wenn Sie einen anderen DNS-Anbieter verwenden, müssen Sie `lambda.region.amazonaws.co`, Ihrem Lambda-Schnittstellenendpunkt zuordnen.