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.

# Erstellen Sie ein benutzerdefiniertes Modell (AWS SDKs)
<a name="create-custom-model-sdks"></a>

Um ein benutzerdefiniertes Modell aus einem SageMaker KI-trainierten Amazon Nova-Modell zu erstellen, das in Amazon S3 gespeichert ist, verwenden Sie den [CreateCustomModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateCustomModel.html)API-Vorgang. Sie können den folgenden Code verwenden, um ein benutzerdefiniertes Modell mit dem SDK für Python (Boto3) zu erstellen. Der Code erstellt ein benutzerdefiniertes Modell und überprüft dann seinen Status, bis es `ACTIVE` und einsatzbereit ist.

Um den Code zu verwenden, aktualisieren Sie die folgenden Parameter. Das Codebeispiel enthält auch optionale Parameter, z. B. `clientRequestToken` für Idempotenz und `modelTags` für Ressourcenmarkierung. 
+ **modelName** – Geben Sie dem Modell einen eindeutigen Namen.
+ **s3URI** — Geben Sie den Pfad zum von Amazon verwalteten Amazon S3-Bucket an, in dem Ihre Modellartefakte gespeichert sind. SageMaker KI erstellt diesen Bucket, wenn Sie Ihren ersten SageMaker KI-Trainingsjob ausführen.
+ **roleArn** – Geben Sie den Amazon-Ressourcennamen (ARN) einer IAM-Servicerolle an, die Amazon Bedrock für die Ausführung von Aufgaben in Ihrem Namen übernimmt. Weitere Informationen zum Erstellen dieser Rolle finden Sie unter [Erstellen einer Servicerolle für den Import von vortrainierten Modellen](model-import-iam-role.md).
+ **modelKmsKeyArn** (optional) — Geben Sie einen AWS KMS Schlüssel an, um das Modell in Amazon Bedrock zu verschlüsseln. Wenn Sie keinen AWS KMS Schlüssel angeben, verwendet Amazon Bedrock einen AWS verwalteten AWS KMS Schlüssel, um das Modell zu verschlüsseln. Weitere Informationen zur Verschlüsselung finden Sie unter [Verschlüsselung importierter benutzerdefinierter Modelle](encryption-import-model.md).

Nachdem Sie das benutzerdefinierte Modell erstellt haben, wird das Modell in der [ListCustomModels](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListCustomModels.html)Antwort mit einem von angezeigt. `customizationType` `imported` Um den Status des neuen Modells zu verfolgen, verwenden Sie den [GetCustomModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetCustomModel.html)API-Vorgang.

```
import boto3
import uuid
from botocore.exceptions import ClientError
import time

def create_custom_model(bedrock_client):
    """
    Creates a custom model in Amazon Bedrock from a SageMaker AI-trained Amazon Nova model stored in Amazon S3.
    Args:
        bedrock_client: The Amazon Bedrock client instance
    Returns:
        dict: Response from the CreateCustomModel API call
    """
    try:
        # Create a unique client request token for idempotency
        client_request_token = str(uuid.uuid4())

        # Define the model source configuration
        model_source_config = {
            's3DataSource': {
                's3Uri': '{{s3://amzn-s3-demo-bucket/folder/}}',
            }
        }

        # Create the custom model
        response = bedrock_client.create_custom_model(
            # Required parameters
            modelName='{{modelName}}',
            roleArn='{{serviceRoleArn}}',
            modelSourceConfig=model_source_config,

            # Optional parameters
            clientRequestToken=client_request_token,
            modelKmsKeyArn='{{keyArn}}',
            modelTags=[
                {
                    'key': 'Environment',
                    'value': 'Production'
                },
                {
                    'key': 'Project',
                    'value': 'AIInference'
                }
            ]
        )

        print(f"Custom model creation initiated. Model ARN: {response['modelArn']}")

        return response

    except ClientError as e:
        print(f"Error creating custom model: {e}")
        raise

def list_custom_models(bedrock_client):
    """
    Lists all custom models in Amazon Bedrock.

    Args:
        bedrock_client: An Amazon Bedrock client.

    Returns:
        dict: Response from the ListCustomModels API call

    """

    try:
        response = bedrock_client.list_custom_models()
        print(f"Total number of custom models: {len(response['modelSummaries'])}")

        for model in response['modelSummaries']:
            print("ARN: " + model['modelArn'])
            print("Name: " + model['modelName'])
            print("Status: " + model['modelStatus'])
            print("Customization type: " + model['customizationType'])
            print("------------------------------------------------------")

        return response

    except ClientError as e:
        print(f"Error listing custom models: {e}")
        raise

def check_model_status(bedrock_client, model_arn):
    """
    Checks the status of a custom model creation.

    Args:
        model_arn (str): The ARN of the custom model
        bedrock_client: An Amazon Bedrock client.

    Returns:
        dict: Response from the GetCustomModel API call

    """

    try:
        max_time = time.time() + 60 * 60  # 1 hour

        while time.time() < max_time:
            response = bedrock_client.get_custom_model(modelIdentifier=model_arn)
            status = response.get('modelStatus')
            print(f"Job status: {status}")
            if status == 'Failed':
                print(f"Failure reason: {response.get('failureMessage')}")
                break
            if status == 'Active':
                print("Model is ready for use.")
                break
            time.sleep(60)

    except ClientError as e:
        print(f"Error checking model status: {e}")
        raise


def main():
    bedrock_client = boto3.client(service_name='bedrock', region_name='{{REGION}}')
    
    # Create the custom model
    model_arn = create_custom_model(bedrock_client)["modelArn"]

    # Check the status of the model
    if model_arn:
        check_model_status(bedrock_client, model_arn)

    # View all custom models
    list_custom_models(bedrock_client)


if __name__ == "__main__":
    main()
```