Prérequis et configuration Interrogez les données avec Trusted Identity Propagation via Amazon SageMaker Unified Studio Résolution des problèmes nettoyer des ressources ;Étapes suivantes

Utilisation de la propagation d'identité sécurisée avec Amazon SageMaker Unified Studio

Ce didacticiel montre comment configurer une application EMR Serverless avec Trusted Identity Propagation (TIP). Vous interrogez ensuite un exemple de table à l'aide de contrôles d'accès basés sur l'identité via Amazon SageMaker Unified Studio. Avec cette configuration, EMR Serverless exécute les requêtes Spark de chaque utilisateur avec sa propre identité IAM Identity Center, et Lake Formation applique les autorisations par utilisateur sur AWS les tables du catalogue de données Glue.

TIP non pris en charge dans les charges de travail interactives d'EMR Studio

Les charges de travail interactives via EMR Studio ne prennent pas en charge la propagation sécurisée des identités avec EMR Serverless. Utilisez Amazon SageMaker Unified Studio comme application orientée client pour les charges de travail TIP-enabled interactives.

Coûts

Ce didacticiel utilise AWS des services susceptibles d'entraîner des frais, notamment EMR Serverless, AWS Lake Formation AWS IAM Identity Center, Amazon Simple Storage Service et Amazon SageMaker Unified Studio. Pour éviter des frais permanents, suivez les étapes de nettoyage décrites à la fin de ce didacticiel. Pour plus d'informations sur les tarifs, consultez la page de tarification de chaque service.

Prérequis et configuration

Effectuez les étapes suivantes pour configurer toutes les ressources requises avant d'interroger les données à l'aide d'une propagation d'identité sécurisée.

Étape 1 : configurer IAM Identity Center

Activez IAM Identity Center dans votre AWS compte. Une instance IAM Identity Center ne peut exister que dans une seule région par compte.

Important
Notez dans quelle région votre IAM Identity Center est déployé. Toutes les ressources suivantes (Lake Formation, EMR Serverless, AWS Glue) doivent être créées dans la même région. Par exemple, si votre IAM Identity Center se trouve dans us-west-2, toutes les ressources doivent également se trouver dans us-west-2.
Provisionnez des utilisateurs et des groupes dans IAM Identity Center, soit manuellement, soit en les synchronisant à partir d'un fournisseur d'identité externe (tel qu'Okta ou Microsoft Entra ID).

Notez l'ARN de votre instance IAM Identity Center. Vous en aurez besoin pour les étapes suivantes. Retrouvez-le dans la console IAM Identity Center, sous Paramètres.

Pour rechercher votre instance par programmation, exécutez :


aws sso-admin list-instances --region your-region

Exemple de sortie :


{
    "Instances": [
        {
            "InstanceArn": "arn:aws:sso:::instance/ssoins-1234567890abcdef",
            "IdentityStoreId": "d-1234567890",
            "OwnerAccountId": "123456789012",
            "Status": "ACTIVE"
        }
    ]
}

Étape 2 : configurer Lake Formation avec IAM Identity Center

Ouvrez la console Lake Formation.
Configurez un administrateur de lac de données.

Important
Assurez-vous que le rôle ou l'utilisateur IAM que vous utilisez pour exécuter ces commandes est ajouté en tant qu'administrateur de Data Lake dans Lake Formation. Sinon, vous recevrez des erreurs « Autorisations insuffisantes pour la formation lacustre » lors de la création de bases de données ou de tables. Pour ajouter votre rôle en tant qu'administrateur :
```
aws lakeformation put-data-lake-settings \
    --data-lake-settings '{
        "DataLakeAdmins": [
            {"DataLakePrincipalIdentifier": "arn:aws:iam::account-id:role/your-role"}
        ],
        "CreateDatabaseDefaultPermissions": [],
        "CreateTableDefaultPermissions": [],
        "Parameters": {"CROSS_ACCOUNT_VERSION": "3", "SET_CONTEXT": "TRUE"}
    }'
```

Créez l'intégration IAM Identity Center pour Lake Formation à l'aide de l'ARN de l'instance que vous avez noté à l'étape 1 :


aws lakeformation create-lake-formation-identity-center-configuration \
    --catalog-id account-id \
    --instance-arn "arn:aws:sso:::instance/ssoins-instance-id"

Créez un rôle IAM pour l'enregistrement de l'emplacement de Lake Formation. N'utilisez pas le rôle lié à un service pour une propagation d'identité sécurisée. Pour plus d'informations, consultez Configuration de AWS Lake Formation avec IAM Identity Center.

Politique de confiance :


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

sts : SetContext est obligatoire

La politique de confiance doit inclure sts:SetContext ce qui est requis pour une propagation d'identité fiable. Le rôle IAM créé par l'assistant par défaut est un rôle lié à un service et n'inclut pas. sts:SetContext Si vous avez précédemment enregistré un emplacement avec le rôle lié à un service, vous devez le réenregistrer avec un rôle personnalisé qui inclut. sts:SetContext

Politique d'autorisation (autorise l'accès à l'emplacement des données Amazon S3) :


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "LakeFormationDataAccessPermissionsForS3",
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:DeleteObject"
            ],
            "Resource": [
                "arn:aws:s3:::your-data-bucket/*"
            ]
        },
        {
            "Sid": "LakeFormationDataAccessPermissionsForS3ListBucket",
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::your-data-bucket"
            ]
        }
    ]
}

Créez le rôle et joignez la politique :


aws iam create-role \
    --role-name LFLocationRegistrationRole \
    --assume-role-policy-document file://lf-trust-policy.json \
    --description "Lake Formation location registration role with sts:SetContext for TIP"

aws iam put-role-policy \
    --role-name LFLocationRegistrationRole \
    --policy-name LFDataAccessPolicy \
    --policy-document file://lf-permissions-policy.json

Enregistrez votre emplacement de données Amazon S3 auprès de Lake Formation en utilisant le rôle que vous avez créé :


aws lakeformation register-resource \
    --resource-arn "arn:aws:s3:::your-data-bucket" \
    --role-arn "arn:aws:iam::account-id:role/LFLocationRegistrationRole"

Créez une base de données et un tableau dans le catalogue de données AWS Glue pointant vers vos exemples de données.
Accordez des autorisations aux utilisateurs ou aux groupes d'IAM Identity Center à la fois sur la base de données et sur la table.

Important
Vous devez accorder DESCRIBE sur la base de données en plus de SELECT et DESCRIBE sur la table. Sans autorisations au niveau de la base de données, celle-ci n'apparaîtra pas dans les résultats de SHOW DATABASES lors de l'utilisation de l'accès basé sur l'identité.

À l'aide de la console :
1. Dans la console Lake Formation, choisissez Autorisations relatives aux lacs de données > Accorder.
2. Dans Principals, choisissez Utilisateurs et groupes IAM Identity Center, puis sélectionnez votre utilisateur ou votre groupe.
3. Sous Ressources du catalogue de données nommé, sélectionnez votre base de données.
4. Sous Autorisations de base de données, sélectionnez Décrire.
5. Choisissez Accorder.
6. Répétez les étapes 1 à 5, en sélectionnant cette fois la table et en accordant les autorisations Sélectionner et décrire sous la table.
À l'aide de AWS CLI :

Important
Le principal format d'identifiant pour les utilisateurs de l'IAM Identity Center dans les subventions Lake Formation est le suivant :arn:aws:identitystore:::user/<UserId>. Notez les trois points (: : :). Aucune région ni aucun compte n'est spécifié. UserId Obtenez-le sur l'Identity Store :
```
# List users to get their UserIds
aws identitystore list-users --identity-store-id identity-store-id --region your-region

# Grant DESCRIBE on the database
aws lakeformation grant-permissions \
    --principal '{"DataLakePrincipalIdentifier": "arn:aws:identitystore:::user/UserId"}' \
    --permissions '["DESCRIBE"]' \
    --resource '{"Database": {"DatabaseName": "tip_tutorial_db", "CatalogId": "account-id"}}'

# Grant SELECT and DESCRIBE on the table
aws lakeformation grant-permissions \
    --principal '{"DataLakePrincipalIdentifier": "arn:aws:identitystore:::user/UserId"}' \
    --permissions '["SELECT","DESCRIBE"]' \
    --resource '{"Table": {"DatabaseName": "tip_tutorial_db", "Name": "employees", "CatalogId": "account-id"}}'
```

Étape 3 : Création de l'application TIP-enabled EMR Serverless

Assurez-vous que votre rôle IAM dispose des autorisations IAM Identity Center requises pour créer l'application :


"sso:DescribeInstance",
"sso:CreateApplication", 
"sso:DeleteApplication",
"sso:PutApplicationAuthenticationMethod",
"sso:PutApplicationAssignmentConfiguration",  
"sso:PutApplicationGrant", 
"sso:PutApplicationAccessScope"

Créez l'application avec une propagation d'identité fiable, le point de terminaison Apache Livy activé et le catalogue de données AWS Glue configuré comme métastore :


aws emr-serverless create-application \
    --release-label emr-7.8.0 \
    --type "SPARK" \
    --identity-center-configuration '{"identityCenterInstanceArn": "arn:aws:sso:::instance/ssoins-instance-id"}' \
    --interactive-configuration '{"livyEndpointEnabled":true}' \
    --runtime-configuration '[{"classification": "spark-defaults", "properties": {"spark.sql.catalogImplementation": "hive", "spark.hadoop.hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory"}}]'

Important

AWS CLI version requise : les --runtime-configuration indicateurs --identity-center-configuration--interactive-configuration, et nécessitent la AWS CLI version 2.15+. Si le message d'erreur « Options inconnues » s'affiche, mettez à jour votre version AWS CLI ou utilisez Python boto3 (v1.35+) comme alternative :


import boto3

session = boto3.Session(profile_name='your-profile', region_name='your-region')
client = session.client('emr-serverless')

response = client.create_application(
    name='tip-tutorial-app',
    releaseLabel='emr-7.8.0',
    type='SPARK',
    identityCenterConfiguration={
        'identityCenterInstanceArn': 'arn:aws:sso:::instance/ssoins-instance-id'
    },
    interactiveConfiguration={
        'livyEndpointEnabled': True
    },
    runtimeConfiguration=[
        {
            'classification': 'spark-defaults',
            'properties': {
                'spark.sql.catalogImplementation': 'hive',
                'spark.hadoop.hive.metastore.client.factory.class': 'com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory'
            }
        }
    ]
)
print(response['applicationId'])

Configuration de la métastore Glue Data Catalog

Le runtimeConfiguration paramètre spark.sql.catalogImplementation et la classe AWS Glue Metastore Factory garantissent que les sessions Spark peuvent accéder à tous les types de tables (CSV, Parquet, ORC, Iceberg) dans le AWS catalogue de données Glue. Sans cette configuration, seules les tables Iceberg pourraient être visibles.

Le point de terminaison Apache Livy est requis pour TIP

Une propagation d'identité fiable nécessite--interactive-configuration '{"livyEndpointEnabled":true}'. TIP est activé pour le point de terminaison Apache Livy uniquement.

Si vous ne disposez pas des autorisations IAM Identity Center requises, créez l'application sans le --identity-center-configuration paramètre et demandez à votre administrateur IAM Identity Center d'activer TIP ultérieurement à l'aide de l'API de mise à jour de l'application :


aws emr-serverless update-application \
    --application-id application-id \
    --identity-center-configuration '{"identityCenterInstanceArn": "arn:aws:sso:::instance/ssoins-instance-id"}'

Étape 4 : Configuration du rôle d'exécution des tâches

La politique de confiance du rôle d'exécution des tâches doit inclure sts:SetContext pour permettre à EMR Serverless d'améliorer les informations d'identification avec l'identité de l'utilisateur :


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

Créez le rôle :


aws iam create-role \
    --role-name emr-serverless-tip-job-role \
    --assume-role-policy-document file://trust-policy.json \
    --description "EMR Serverless job execution role with TIP support"

Joignez des autorisations pour les services en aval auxquels la tâche aura accès. Le rôle nécessite les autorisations Lake Formation, AWS Glue, Amazon S3 et Amazon CloudWatch Logs :


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "LakeFormationAndGlueAccess",
            "Effect": "Allow",
            "Action": [
                "lakeformation:GetDataAccess",
                "glue:GetTable", "glue:GetTables",
                "glue:GetDatabase", "glue:GetDatabases",
                "glue:GetPartitions"
            ],
            "Resource": "*"
        },
        {
            "Sid": "S3DataAccess",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket",
                "s3:GetBucketLocation"
            ],
            "Resource": [
                "arn:aws:s3:::your-data-bucket",
                "arn:aws:s3:::your-data-bucket/*"
            ]
        },
        {
            "Sid": "CloudWatchLogsAccess",
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents",
                "logs:DescribeLogGroups",
                "logs:DescribeLogStreams"
            ],
            "Resource": "arn:aws:logs:us-east-1:111122223333:*"
        }
    ]
}

Les autorisations S3 sont requises en plus des autorisations de Lake Formation

Les autorisations Amazon S3 (s3:GetObject,s3:PutObject,s3:ListBucket) sur votre compartiment de données sont requises en plus des autorisations Lake Formation et AWS Glue. L's3:PutObjectautorisation est requise pour Spark Scratch and Shuffle Data. Sans les autorisations Amazon S3, les tâches Spark peuvent échouer et entraîner des erreurs d'accès refusé lors de la lecture des fichiers de données sous-jacents ou de l'écriture de données temporaires.

CloudWatch Les autorisations relatives aux journaux sont requises

Les autorisations Amazon CloudWatch Logs sont requises pour la livraison des journaux du pilote et de l'exécuteur Spark. Sans eux, les sessions Spark risquent de ne pas démarrer.

Attachez la stratégie au rôle :


aws iam put-role-policy \
    --role-name emr-serverless-tip-job-role \
    --policy-name tip-lakeformation-access \
    --policy-document file://permissions-policy.json

Accordez les autorisations à Lake Formation pour le rôle d'exécution des tâches :

Le rôle d'exécution des tâches nécessite également des autorisations Lake Formation sur la base de données et la table. Cela s'ajoute aux autorisations accordées à l'utilisateur de l'IAM Identity Center.


# Grant DESCRIBE on the database to the job role
aws lakeformation grant-permissions \
    --principal '{"DataLakePrincipalIdentifier": "arn:aws:iam::account-id:role/emr-serverless-tip-job-role"}' \
    --permissions '["DESCRIBE"]' \
    --resource '{"Database": {"DatabaseName": "tip_tutorial_db", "CatalogId": "account-id"}}'

# Grant SELECT and DESCRIBE on the table to the job role
aws lakeformation grant-permissions \
    --principal '{"DataLakePrincipalIdentifier": "arn:aws:iam::account-id:role/emr-serverless-tip-job-role"}' \
    --permissions '["SELECT","DESCRIBE"]' \
    --resource '{"Table": {"DatabaseName": "tip_tutorial_db", "Name": "employees", "CatalogId": "account-id"}}'

Pour des configurations de service en aval supplémentaires, consultez Utilisation de Lake Formation avec EMR Serverless et Utilisation d'Amazon S3 Access Grants avec EMR Serverless.

Interrogez les données avec Trusted Identity Propagation via Amazon SageMaker Unified Studio

Une fois la configuration terminée, vous pouvez interroger des données à l'aide de votre application TIP-enabled EMR Serverless en tant que calcul dans un projet Amazon SageMaker Unified Studio. EMR Serverless exécute les requêtes de chaque utilisateur avec sa propre identité IAM Identity Center, et Lake Formation applique les autorisations par utilisateur.

Conditions préalables

Une application TIP-enabled EMR Serverless (complétée à l'étape 3 ci-dessus).
Un domaine Amazon SageMaker Unified Studio configuré avec l'authentification IAM Identity Center.
Autorisations Lake Formation accordées à votre utilisateur ou à votre groupe IAM Identity Center sur la base de données et la table cibles (effectuées à l'étape 2 ci-dessus).

Étape 5 : Création d'un projet Amazon SageMaker Unified Studio avec TIP activé

Connectez-vous à Amazon SageMaker Unified Studio à l'aide de vos informations d'identification IAM Identity Center.
Créez un nouveau projet ou ouvrez un projet existant.
Dans les paramètres du projet, assurez-vous que le profil est enableTrustedIdentityPropagationPermissions défini sur true les paramètres du plan.

Étape 6 : ajouter l'application EMR Serverless en tant que calcul

La configuration informatique du projet Amazon SageMaker Unified Studio ne prend actuellement pas en charge l'ajout d'une application EMR Serverless existante via la console. Utilisez le AWS CLI pour créer la connexion :


aws datazone create-connection \
  --domain-identifier domain-id \
  --name "my-emr-serverless-connection" \
  --environment-identifier environment-id \
  --props '{
    "sparkEmrProperties": {
      "computeArn": "arn:aws:emr-serverless:region:account-id:/applications/application-id",
      "runtimeRole": "arn:aws:iam::account-id:role/emr-serverless-tip-job-role"
    }
  }'

Remplacez les valeurs suivantes :

domain-id: votre identifiant de domaine Amazon SageMaker Unified Studio.
environment-id: L'identifiant de l'environnement de votre projet (utilisez l'environnement Tooling).
application-id: ID de l'application EMR Serverless de l'étape 3.
emr-serverless-tip-job-role: le rôle d'exécution des tâches décrit à l'étape 4.

Important

L'create-connectionAPI nécessite que l'appelant soit membre du DataZone projet. Si vous recevez un messageAccessDeniedException, ajoutez votre rôle IAM en tant que contributeur au projet avant de créer la connexion :


import boto3

session = boto3.Session(profile_name='your-profile', region_name='your-region')
client = session.client('datazone')

client.create_project_membership(
    domainIdentifier='domain-id',
    projectIdentifier='project-id',
    designation='PROJECT_CONTRIBUTOR',
    member={'userIdentifier': 'arn:aws:iam::account-id:role/your-role'}
)

Configurez le rôle DataZone utilisateur du projet pour l'accès EMR Serverless.

Le rôle DataZone utilisateur pour l'environnement du projet doit être autorisé à interagir avec l'application EMR Serverless. Ajoutez la politique en ligne suivante au rôle (le nom du rôle suit le modèledatazone_usr_role_<project-id>_<environment-id>) :


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "emr-serverless:GetApplication",
                "emr-serverless:StartApplication",
                "emr-serverless:StopApplication",
                "emr-serverless:ListApplications",
                "emr-serverless:AccessLivyEndpoints",
                "emr-serverless:StartJobRun",
                "emr-serverless:GetJobRun",
                "emr-serverless:ListJobRuns",
                "emr-serverless:CancelJobRun",
                "emr-serverless:GetDashboardForJobRun"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::111122223333:role/emr-serverless-tip-job-role",
            "Condition": {
                "StringLike": {
                    "iam:PassedToService": "emr-serverless.amazonaws.com"
                }
            }
        }
    ]
}

Accordez les autorisations de Lake Formation au rôle DataZone d'utilisateur :


# Grant DESCRIBE on the database
aws lakeformation grant-permissions \
    --principal '{"DataLakePrincipalIdentifier": "arn:aws:iam::account-id:role/datazone_usr_role_project-id_environment-id"}' \
    --permissions '["DESCRIBE"]' \
    --resource '{"Database": {"DatabaseName": "tip_tutorial_db", "CatalogId": "account-id"}}'

# Grant SELECT and DESCRIBE on the table
aws lakeformation grant-permissions \
    --principal '{"DataLakePrincipalIdentifier": "arn:aws:iam::account-id:role/datazone_usr_role_project-id_environment-id"}' \
    --permissions '["SELECT","DESCRIBE"]' \
    --resource '{"Table": {"DatabaseName": "tip_tutorial_db", "Name": "employees", "CatalogId": "account-id"}}'

Limitation de la console pour les connexions EMR Serverless

Amazon SageMaker Unified Studio prend actuellement en charge l'ajout d'Amazon EMR existant sur des clusters EC2 via la configuration informatique de la console. Pour les applications EMR Serverless, utilisez la AWS CLI méthode décrite ci-dessus.

Étape 7 : Interrogez un exemple de tableau

Ouvrez un espace JupyterLab IDE dans votre projet Amazon SageMaker Unified Studio.
Sélectionnez la connexion EMR Serverless comme ordinateur pour l'exécution sur ordinateur portable.

Dans une nouvelle cellule de bloc-notes, exécutez les PySpark requêtes suivantes :


%%pyspark my-emr-serverless-connection
spark.sql("SHOW DATABASES").show()

%%pyspark my-emr-serverless-connection
spark.sql("SELECT * FROM tip_tutorial_db.employees LIMIT 10").show()

Vérifiez que la requête renvoie des données. Cela confirme que votre identité IAM Identity Center a été transmise à Lake Formation et que l'accès a été accordé sur la base de votre identité.

Démarrage à froid de l'application

La première fois que vous exécutez une cellule après avoir créé la connexion, EMR Serverless démarre l'application (démarrage à froid). Cela peut prendre de 2 à 3 minutes. Les cellules suivantes s'exécutent en quelques secondes pendant que la session est active.

Résolution des erreurs d’accès refusé

Si vous recevez un message d'erreur d'accès refusé, vérifiez que :

Votre utilisateur ou groupe IAM Identity Center a reçu l'autorisation DESCRIBE dans la base de données et SELECT/DESCRIBE sur la table de Lake Formation.
Le rôle d'exécution des tâches dispose lakeformation:GetDataAccess des autorisations et des autorisations AWS Glue Data Catalog.
Le rôle DataZone utilisateur dispose des autorisations Lake Formation sur la base de données et la table.
L'emplacement Amazon S3 de Lake Formation est enregistré avec un rôle personnalisé qui inclut sts:SetContext (et non le rôle lié au service).

Résolution des problèmes

Erreur	Cause	Corriger
`AccessDeniedException: emr-serverless:GetApplication`	Le rôle DataZone utilisateur ne dispose pas des autorisations EMR Serverless.	Ajoutez la politique en ligne EMR Serverless au rôle DataZone utilisateur (voir Étape 6).
Délai expiré en attente pour que la demande atteigne le statut DÉMARRÉ	Le démarrage à froid de l'application EMR Serverless dépasse le délai d'expiration par défaut.	Re-run la cellule. L'application continue de démarrer en arrière-plan et sera prête à la prochaine tentative.
Session introuvable. Nettoyé en raison d'un délai d'inactivité.	La session Spark n'a pas pu démarrer en raison d'autorisations insuffisantes sur le rôle d'exécution des tâches.	Assurez-vous que le rôle d'exécution des tâches dispose des autorisations Amazon S3, Amazon CloudWatch Logs, AWS Glue et Lake Formation (voir Étape 4).
Autorisation (s) insuffisante (s) pour la formation de lacs : obligatoire Décrire dans la base de données	Votre identité ou votre rôle ne dispose pas d'autorisations Lake Formation au niveau de la base de données.	Accordez DESCRIBE sur la base de données à l'utilisateur, au rôle d'exécution des tâches et au rôle DataZone utilisateur d'IAM Identity Center.
`TABLE_OR_VIEW_NOT_FOUND`	La session Spark n'est pas configurée pour utiliser le catalogue de données AWS Glue.	Assurez-vous que l'application EMR Serverless inclut `spark.sql.catalogImplementation=hive` et inclut la classe AWS Glue Metastore Factory dans son application `runtimeConfiguration` (voir Étape 3).
`AccessDeniedException: CreateConnection`	L'appelant n'est pas membre du DataZone projet.	Ajoutez votre rôle en tant que contributeur au projet avant d'appeler `create-connection` (voir Étape 6).

nettoyer des ressources ;

Pour éviter des frais continus, supprimez les ressources que vous avez créées pour ce tutoriel :

Supprimez l'application EMR Serverless.
Supprimez la connexion Amazon SageMaker Unified Studio et supprimez le projet Amazon SageMaker Unified Studio (et le domaine, si vous l'avez créé uniquement pour ce didacticiel).
Révoquez les autorisations que vous avez accordées à Lake Formation et désenregistrez l'emplacement des données Amazon S3.
Supprimez les rôles IAM que vous avez créés aux étapes 2 et 4.
Supprimez tous les compartiments Amazon S3 de test et les échantillons de données.

Étapes suivantes

Pour vérifier la propagation de l'identité dans CloudTrail, recherchez les AssumeRole événements sts:SetContext provenant du service EMR Serverless.
Pour restreindre l'accès à différents utilisateurs, créez des utilisateurs IAM Identity Center supplémentaires et accordez-leur différentes autorisations Lake Formation sur la même table (par exemple, filtrage au niveau des colonnes ou des lignes).
Pour les déploiements en production, attribuez les autorisations Amazon S3 et AWS Glue du rôle d'exécution des tâches à des ressources spécifiques plutôt que d'utiliser des caractères génériques.
Pour plus d'informations sur l'utilisation d'EMR Serverless avec Amazon SageMaker Unified Studio, consultez EMR Serverless dans Amazon Unified Studio. SageMaker

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilisation de dbt-core

Sécurité