Déchargez les données d'un cluster Amazon Redshift entre différents comptes vers Amazon S3 - Recommandations AWS
RécapitulatifConditions préalables et limitationsArchitectureOutilsBonnes pratiquesÉpopéesRessources connexesInformations supplémentaires

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.

Déchargez les données d'un cluster Amazon Redshift entre différents comptes vers Amazon S3

Créée par Andrew Kamel () AWS

Dépôt de code : aws-unload-redshift-to-s3-python

Environnement : Production

Technologies : bases de données ; analyse ; sans serveur

Charge de travail : Open source

AWSservices : AWS Lambda ; Amazon Redshift ; Amazon S3 ; Secrets Manager AWS

Récapitulatif

Lorsque vous testez des applications, il est utile de disposer de données de production dans votre environnement de test. L'utilisation des données de production peut vous donner une évaluation plus précise de l'application que vous développez.

Ce modèle extrait les données d'un cluster Amazon Redshift dans un environnement de production vers un bucket Amazon Simple Storage Service (Amazon S3) dans un environnement de développement sur Amazon Web Services ().AWS

Le schéma décrit les étapes de configuration DEV des deux PROD comptes, notamment les suivantes :

  • Ressources requises

  • AWS Identity and Access Management (IAM) rôles

  • Ajustements réseau apportés aux sous-réseaux, aux groupes de sécurité et au cloud privé virtuel (VPC) pour prendre en charge la connexion Amazon Redshift

  • Exemple de AWS Lambda fonction avec un environnement d'exécution Python pour tester l'architecture

Pour accorder l'accès au cluster Amazon Redshift, le modèle permet de stocker les AWS Secrets Manager informations d'identification pertinentes. L'avantage est de disposer de toutes les informations nécessaires pour se connecter directement au cluster Amazon Redshift sans avoir besoin de savoir où se trouve le cluster Amazon Redshift. De plus, vous pouvez contrôler l'utilisation du secret.

Le secret enregistré dans Secrets Manager inclut l'hôte du cluster Amazon Redshift, le nom de la base de données, le port et les informations d'identification pertinentes.

Pour plus d'informations sur les considérations de sécurité liées à l'utilisation de ce modèle, consultez la section Bonnes pratiques.

Conditions préalables et limitations

Prérequis

Limites

  • En fonction de la quantité de données que vous souhaitez interroger, le délai d'expiration de la fonction Lambda peut être dépassé.

    Si votre exécution prend plus de temps que le délai maximum Lambda (15 minutes), utilisez une approche asynchrone pour votre code Lambda. L'exemple de code de ce modèle utilise la bibliothèque psycopg2 pour Python, qui ne prend actuellement pas en charge le traitement asynchrone.

  • Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, voir Services AWS par région. Pour des points de terminaison spécifiques, consultez la page Points de terminaison et quotas du service, puis choisissez le lien vers le service.

Architecture

Le schéma suivant montre l'architecture cible, avec DEV les PROD comptes et.

Le Lambda VPC dans le DEV compte et l'Amazon VPC Redshift dans le compte. PROD

Le schéma suivant illustre le flux de travail suivant :

  1. La fonction Lambda du DEV compte IAM joue le rôle requis pour accéder aux informations d'identification Amazon Redshift dans Secrets Manager du compte. PROD

    La fonction Lambda récupère ensuite le secret du cluster Amazon Redshift.

  2. La fonction Lambda du DEV compte utilise les informations pour se connecter au cluster Amazon Redshift du compte via PROD le peered. VPCs

    La fonction Lambda envoie ensuite une commande de déchargement pour interroger le cluster Amazon Redshift dans le compte. PROD

  3. Le cluster Amazon Redshift du PROD compte assume le IAM rôle approprié pour accéder au compartiment S3 du compte. DEV

    Le cluster Amazon Redshift décharge les données demandées dans le compartiment S3 du compte. DEV

Interrogation de données depuis Amazon Redshift

Le schéma suivant montre les rôles utilisés pour récupérer les informations d'identification Amazon Redshift et se connecter au cluster Amazon Redshift. Le flux de travail est lancé par la fonction Lambda.

Le processus en trois étapes pour assumer des rôles sur plusieurs comptes.

Le schéma suivant illustre le flux de travail suivant :

  1. L'CrossAccount-SM-Read-Roleentrée dans le DEV compte suppose l'SM-Read-Roleentrée dans le PROD compte.

  2. Le SM-Read-Role rôle utilise la politique ci-jointe pour récupérer le secret auprès de Secrets Manager.

  3. Les informations d'identification sont utilisées pour accéder au cluster Amazon Redshift.

Chargement de données vers Amazon S3

Le schéma suivant montre le processus de lecture-écriture entre comptes permettant d'extraire des données et de les télécharger sur Amazon S3. Le flux de travail est lancé par la fonction Lambda. Le modèle enchaîne IAM les rôles dans Amazon Redshift. La commande de déchargement qui provient du cluster Amazon Redshift suppose CrossAccount-S3-Write-Role le, puis suppose le. S3-Write-Role Ce chaînage de rôles permet à Amazon Redshift d'accéder à Amazon S3.

Les rôles qui obtiennent des informations d'identification, accèdent à Amazon Redshift et chargent des données vers Amazon S3.

Le flux de travail comprend les étapes suivantes :

  1. L'CrossAccount-SM-Read-Roleentrée dans le DEV compte suppose l'SM-Read-Roleentrée dans le PROD compte.

  2. SM-Read-Rolerécupère les informations d'identification Amazon Redshift auprès de Secrets Manager.

  3. La fonction Lambda se connecte au cluster Amazon Redshift et envoie une requête.

  4. Le cluster Amazon Redshift suppose que. CrossAccount-S3-Write-Role

  5. Cela CrossAccount-S3-Write-Role suppose que c'S3-Write-Roleest dans le DEV compte.

  6. Les résultats de la requête sont déchargés dans le compartiment S3 du DEV compte.

Outils

Services AWS

  • AWS Key Management Service (AWS KMS) vous aide à créer et à contrôler des clés cryptographiques afin de protéger vos données.

  • AWS Lambda est un service de calcul qui vous aide à exécuter du code sans avoir à allouer ni à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez.

  • Amazon Redshift est un service d'entrepôt de données géré à l'échelle du pétaoctet dans le cloud. AWS

  • AWS Secrets Managervous permet de remplacer les informations d'identification codées en dur dans votre code, y compris les mots de passe, en API appelant Secrets Manager pour récupérer le secret par programmation.

  • Amazon Simple Storage Service (Amazon S3) est un service de stockage d'objets basé sur le cloud qui vous permet de stocker, de protéger et de récupérer n'importe quel volume de données.

Référentiel de code

Le code de ce modèle est disponible dans le dépôt GitHub unload-redshift-to-s3-python.

Bonnes pratiques

Avertissement de sécurité

Avant de mettre en œuvre cette solution, tenez compte des recommandations de sécurité importantes suivantes :

  • N'oubliez pas que la connexion des comptes de développement et de production peut augmenter la portée et réduire le niveau de sécurité global. Nous recommandons de ne déployer cette solution que temporairement, en extrayant la portion de données requise, puis en détruisant immédiatement les ressources déployées. Pour détruire les ressources, vous devez supprimer la fonction Lambda, supprimer tous les IAM rôles et politiques créés pour cette solution et révoquer tout accès réseau accordé entre les comptes.

  • Consultez vos équipes de sécurité et de conformité avant de copier des données depuis des environnements de production vers des environnements de développement. Les informations personnellement identifiables (PII), les informations de santé protégées (PHI) et les autres données confidentielles ou réglementées ne doivent généralement pas être copiées de cette manière. Copiez uniquement les informations non confidentielles accessibles au public (par exemple, les données boursières publiques provenant d'une interface de boutique). Envisagez de tokeniser ou d'anonymiser les données, ou de générer des données de test synthétiques, au lieu d'utiliser des données de production dans la mesure du possible. L'un des principes de AWS sécurité consiste à tenir les gens à l'écart des données. En d'autres termes, les développeurs ne doivent pas effectuer d'opérations dans le compte de production.

  • Limitez l'accès à la fonction Lambda dans le compte de développement car elle peut lire les données du cluster Amazon Redshift dans l'environnement de production.

  • Pour éviter de perturber l'environnement de production, appliquez les recommandations suivantes :

    • Utilisez un compte de développement dédié distinct pour les activités de test et de développement.

    • Mettez en œuvre des contrôles d'accès réseau stricts et limitez le trafic entre les comptes au strict nécessaire.

    • Surveillez et auditez l'accès à l'environnement de production et aux sources de données.

    • Mettez en œuvre des contrôles d'accès basés sur le principe du moindre privilège pour toutes les ressources et tous les services concernés.

    • Passez régulièrement en revue et alternez les informations d'identification, telles que AWS Secrets Manager les secrets et les clés d'accès aux IAM rôles.

  • Reportez-vous à la documentation de sécurité suivante pour les services utilisés dans cet article :

La sécurité est une priorité absolue lors de l'accès aux données et aux ressources de production. Suivez toujours les meilleures pratiques, mettez en œuvre des contrôles d'accès fondés sur le moindre privilège, et révisez et mettez à jour régulièrement vos mesures de sécurité.

Épopées

TâcheDescriptionCompétences requises

Créez un secret pour le cluster Amazon Redshift.

Pour créer le secret du cluster Amazon Redshift, procédez comme suit :

  1. Dans le PROD compte, connectez-vous à la AWS Management Console console Secrets Manager et ouvrez-la à l'adresse https://console.aws.amazon.com/secretsmanager/.

  2. Choisissez Enregistrer un nouveau secret.

  3. Sélectionnez les informations d'identification pour l'entrepôt de données Amazon Redshift.

  4. Pour Nom d'utilisateur et Mot de passe, entrez des valeurs pour votre instance, puis confirmez ou choisissez une valeur pour la clé de chiffrement.

  5. Choisissez l'entrepôt de données Amazon Redshift auquel votre secret aura accès.

  6. Entrez Redshift-Creds-Secret le nom du secret.

  7. Effectuez les étapes de création restantes avec les choix par défaut, puis choisissez Store.

  8. Consultez votre secret et notez la ARN valeur du secret qui a été générée pour identifier le secret.

DevOps ingénieur

Créez un rôle pour accéder à Secrets Manager.

Pour créer le rôle, procédez comme suit :

  1. Dans le PROD compte, ouvrez la IAM console à l'adresse https://console.aws.amazon.com/iam/.

  2. Choisissez Policies (Politiques).

  3. Choisissez Create Policy (Créer une politique).

  4. Choisissez l'JSONonglet, puis entrez une IAM politique telle que la suivante :

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetResourcePolicy",
                "secretsmanager:GetSecretValue",
                "secretsmanager:DescribeSecret",
                "secretsmanager:ListSecretVersionIds"
            ],
            "Resource": [
                "<Redshift-Creds-Secret-ARN>"
            ]
        },
        {
            "Effect": "Allow",
            "Action": "secretsmanager:ListSecrets",
            "Resource": "*"
        }
    ]
}

    Redshift-Creds-Secret-ARNRemplacez-le par le nom de ressource Amazon (ARN) du secret Secrets Manager qui contient les informations et les informations d'identification du cluster Amazon Redshift.

DevOps ingénieur
TâcheDescriptionCompétences requises

Créez un rôle pour accéder au compartiment S3.

Pour créer le rôle permettant d'accéder au compartiment S3, procédez comme suit :

  1. Dans le DEV compte, ouvrez la IAM console.

  2.  Choisissez Policies (Politiques).

  3. Choisissez Create Policy (Créer une politique).

  4.  Choisissez l'JSONonglet, puis entrez une IAM politique telle que la suivante :

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "kmsstmt",
      "Effect": "Allow",
      "Action": [
        "kms:Decrypt",
        "kms:Encrypt",
        "kms:GenerateDataKey"
      ],
      "Resource": [
        "<kms-key-arn>"
      ]
    },
    {
      "Sid": "s3stmt",
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:Get*",
        "s3:List*"
      ],
      "Resource": [
        "arn:aws:s3:::mybucket",
        "arn:aws:s3:::mybucket/*"
      ]
    }
  ]
}

    mybucketRemplacez-le par le nom du compartiment S3 auquel vous souhaitez accéder. De plus, si le compartiment S3 est chiffré, remplacez-le par kms-key-arn la clé ARN of AWS KMS the AWS Key Management Service () utilisée pour chiffrer le compartiment S3. Sinon, vous n'avez pas besoin de AWS KMS cette section dans la politique.

  5. Choisissez Réviser la politique, entrez le S3-Write-Policy nom de la politique, puis choisissez Créer une politique.

  6. Dans le panneau de navigation, choisissez Roles (Rôles).

  7.  Sélectionnez Create role (Créer un rôle).

  8. Pour le rôle d'entité de confiance, choisissez Politique de confiance personnalisée.

  9. Choisissez Next : Permissions, puis sélectionnez la politique S3-Write-Policy que vous avez créée.

  10. Entrez le S3-Write-Role nom du rôle, puis choisissez Créer un rôle.

DevOps ingénieur

Créez le rôle Amazon Redshift.

Pour créer le rôle Amazon Redshift, procédez comme suit :

  1. Dans le PROD compte, ouvrez la IAM console.

  2. Choisissez Policies (Politiques).

  3. Choisissez Create Policy (Créer une politique).

  4. Choisissez l'JSONonglet, puis entrez une IAM politique telle que la suivante :

    {
    "Version": "2012-10-17",
    "Statement": [
            {
            "Sid": "CrossAccountPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "S3-Write-Role-ARN"
        }
    ]
}

    S3-Write-Role-ARNRemplacez-le par le ARN pour S3-Write-Role dans le DEV compte.

  5. Choisissez Réviser la politique, entrez le S3-Write-Role-Assume-Policy nom de la politique, puis choisissez Créer une politique.

  6. Dans le volet de navigation, sélectionnez Rôles, puis Créer un rôle.

  7. Choisissez le AWSservice comme type d'entité de confiance, puis choisissez Redshift, Redshift - Personnalisable.

  8. Choisissez Next : Permissions, puis sélectionnez la politique S3-Write-Role-Assume-Policy que vous avez créée.

  9. Entrez le CrossAccount-S3-Write-Role nom du rôle, puis choisissez Créer un rôle.

  10. Associez le IAM rôle à votre cluster Amazon Redshift.

DevOps ingénieur
TâcheDescriptionCompétences requises

Déployez la fonction Lambda.

Pour déployer une fonction Lambda dans le peeredVPC, procédez comme suit :

  1. Ouvrez la console Lambda à l'adresse. https://console.aws.amazon.com/lambda/

  2. Choisissez Functions.

  3. Sélectionnez Create function (Créer une fonction).

  4. Sous Informations de base, dans Nom de fonction, entrez un nom pour votre fonction.

  5. Pour Runtime, choisissez Python 3.8.

  6. Développez Modifier le rôle d'exécution par défaut, puis effectuez les opérations suivantes :

    1. Choisissez Utiliser un rôle existant.

    2. Pour Rôle existant, sélectionnez le rôle Lambda CrossAccount-RM-Read-Role que vous avez créé précédemment.

  7. Développez les paramètres avancés, puis procédez comme suit :

    1. Cochez la VPC case Activer.

    2. Pour VPC, sélectionnez le pair VPC dans le DEV compte.

    3. Pour les sous-réseaux, sélectionnez le sous-réseau privé.

    4. Pour Groupes de sécurité, sélectionnez le groupe de sécurité par défaut.

  8. Sélectionnez Create function (Créer une fonction).

  9. Ajoutez la bibliothèque psycopg2 en tant que couche à la fonction Lambda.

    Remarque : vous pouvez utiliser une couche déjà déployée depuis le référentiel psycopg2-lambda-layer. Assurez-vous d'utiliser le runtime URL basé sur votre environnement d'exécution Région AWS et celui de Python.

DevOps ingénieur
TâcheDescriptionCompétences requises

Importez les ressources requises.

Pour importer les ressources requises, exécutez les commandes suivantes :

import ast
import boto3
import psycopg2
import base64
from botocore.exceptions import ClientError
Développeur d'applications

Exécutez la fonction de gestion Lambda.

La fonction Lambda utilise AWS Security Token Service (AWS STS) pour l'accès entre comptes et la gestion des informations d'identification temporaires. La fonction utilise l' AssumeRole APIopération pour assumer temporairement les autorisations du sm_read_role IAM rôle.

Pour exécuter la fonction Lambda, utilisez l'exemple de code suivant :

def lambda_handler(event, context):
    sts_client = boto3.client('sts')

    # Secrets Manager Configurations
    secret_name = "redshift_creds"
    sm_region = "eu-west-1"
    sm_read_role = "arn:aws:iam::PROD_ACCOUNT_NUMBER:role/SM-Read-Role"

    # S3 Bucket Configurations
    s3_bucket_path = "s3://mybucket/"
    s3_bucket_region = "eu-west-1"
    s3_write_role = "arn:aws:iam::DEV_ACCOUNT_NUMBER:role/S3-Write-Role"

    # Redshift Configurations
    sql_query = "select * from category"
    redshift_db = "dev"
    redshift_s3_write_role = "arn:aws:iam::PROD_ACCOUNT_NUMBER:role/CrossAccount-S3-Write-Role"

    chained_s3_write_role = "%s,%s" % (redshift_s3_write_role, s3_write_role)

    assumed_role_object = sts_client.assume_role(
        RoleArn=sm_read_role,
        RoleSessionName="CrossAccountRoleAssumption",
        ExternalId="YOUR_EXTERNAL_ID",
    )
    credentials = assumed_role_object['Credentials']

    secret_dict = ast.literal_eval(get_secret(credentials, secret_name, sm_region))
    execute_query(secret_dict, sql_query, s3_bucket_path, chained_s3_write_role, s3_bucket_region, redshift_db)

    return {
        'statusCode': 200
    }
Développeur d'applications

Découvrez le secret.

Pour obtenir le secret Amazon Redshift, utilisez l'exemple de code suivant :

def get_secret(credentials, secret_name, sm_region):
    # Create a Secrets Manager client
    session = boto3.session.Session()
    sm_client = session.client(
        service_name='secretsmanager',
        aws_access_key_id=credentials['AccessKeyId'],
        aws_secret_access_key=credentials['SecretAccessKey'],
        aws_session_token=credentials['SessionToken'],
        region_name=sm_region
    )

    try:
        get_secret_value_response = sm_client.get_secret_value(
            SecretId=secret_name
        )
    except ClientError as e:
        print(e)
        raise e
    else:
        if 'SecretString' in get_secret_value_response:
            return get_secret_value_response['SecretString']
        else:
            return base64.b64decode(get_secret_value_response['SecretBinary'])
Développeur d'applications

Exécutez la commande de déchargement.

Pour décharger les données dans le compartiment S3, utilisez l'exemple de code suivant.

def execute_query(secret_dict, sql_query, s3_bucket_path, chained_s3_write_role, s3_bucket_region, redshift_db):
    conn_string = "dbname='%s' port='%s' user='%s' password='%s' host='%s'" \
                  % (redshift_db,
                     secret_dict["port"],
                     secret_dict["username"],
                     secret_dict["password"],
                     secret_dict["host"])

    con = psycopg2.connect(conn_string)

    unload_command = "UNLOAD ('{}') TO '{}' IAM_ROLE '{}' DELIMITER '|' REGION '{}';" \
        .format(sql_query,
                s3_bucket_path + str(datetime.datetime.now()) + ".csv",
                chained_s3_write_role,
                s3_bucket_region)

    # Opening a cursor and run query
    cur = con.cursor()
    cur.execute(unload_command)

    print(cur.fetchone())
    cur.close()
    con.close()
Développeur d'applications
TâcheDescriptionCompétences requises

Supprimez la fonction Lambda.

Pour éviter d'encourir des coûts imprévus, supprimez les ressources et la connexion entre les DEV comptes et. PROD

Pour supprimer la fonction Lambda, procédez comme suit :

  1. Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.

  2. Localisez et sélectionnez la fonction Lambda que vous avez créée.

  3. Choisissez Actions, puis Supprimer.

  4. Confirmez la suppression.

DevOps ingénieur

Supprimez les IAM rôles et les politiques.

Supprimez les IAM rôles et les politiques des PROD comptes DEV et.

Dans le DEV compte, procédez comme suit :

  1. Ouvrez la IAM console.

  2. Supprimez les rôles suivants :

    • S3-Write-Role

    • CrossAccount-RM-Read-Role(Rôle Lambda)

  3. Supprimez les politiques associées :

    • S3-Write-Policy

    • La CrossAccount politique d'attribution des rôles PROD liés aux comptes

Dans le PROD compte, procédez comme suit :

  1. Ouvrez la IAM console.

  2. Supprimez les rôles suivants :

    • SM-Read-Role

    • CrossAccount-S3-Write-Role

  3. Supprimez les politiques associées :

    • CrossAccount Politique d'accès à Secrets Manager

    • S3-Write-Role-Assume-Policy

DevOps ingénieur

Supprimez le secret dans Secrets Manager.

Pour supprimer le secret, procédez comme suit :

  1. Dans le PROD compte, ouvrez la console Secrets Manager.

  2. Localisez et sélectionnez le secret nomméRedshift-Creds-Secret.

  3. Choisissez Actions, puis Delete secret (Supprimer le secret).

  4. Confirmez la suppression.

DevOps ingénieur

Supprimez les règles VPC de peering et de groupe de sécurité.

Pour supprimer les règles VPC de peering et de groupe de sécurité, procédez comme suit :

  1. Dans le PROD compte, ouvrez la EC2 console Amazon à l'adresse https://console.aws.amazon.com/ec2/.

  2. Accédez aux groupes de sécurité.

  3. Trouvez le groupe de sécurité utilisé par le cluster Amazon Redshift.

  4. Modifiez les règles entrantes et supprimez la règle qui autorise les connexions depuis le Lambda VPC du DEV compte.

  5. Accédez à Connexions VPC d'appairage et supprimez la connexion d'appairage.

DevOps ingénieur

Supprimez les données du compartiment S3.

Pour supprimer les données d'Amazon S3, procédez comme suit :

  1. Dans le DEV compte, ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.

  2. Localisez le compartiment que vous avez utilisé pour le stockage des données.

  3. Supprimez les objets contenus dans le compartiment ou supprimez le compartiment dans son intégralité s'il n'est plus nécessaire.

DevOps ingénieur

Nettoyez AWS KMS les clés.

Si vous avez créé des AWS KMS clés personnalisées pour le chiffrement, procédez comme suit :

  1. Ouvrez la AWS KMS console à l'adresse https://console.aws.amazon.com/kms/.

  2. Localisez toutes les clés créées pour ce modèle.

  3. Planifiez la suppression des clés. (Il existe une période d'attente obligatoire pour la suppression des clés).

DevOps ingénieur

Vérifiez et supprimez les CloudWatch journaux Amazon.

Pour supprimer les CloudWatch journaux, procédez comme suit :

  1. Ouvrez la CloudWatch console à l'adresse https://console.aws.amazon.com/cloudwatch/.

  2. Vérifiez les groupes de journaux créés par votre fonction Lambda ou votre cluster Amazon Redshift.

  3. Supprimez ces groupes de journaux s'ils ne sont plus nécessaires.

DevOps ingénieur

Ressources connexes

Informations supplémentaires

Après avoir déchargé les données d'Amazon Redshift vers Amazon S3, vous pouvez les analyser à l'aide d'Amazon Athena.

Amazon Athena est un service de requêtes de données volumineuses qui s'avère utile lorsque vous devez accéder à de gros volumes de données. Vous pouvez utiliser Athena sans avoir à approvisionner des serveurs ou des bases de données. Athena prend en charge les requêtes complexes et vous pouvez l'exécuter sur différents objets.

Comme pour la plupart des autres Services AWS, le principal avantage d'Athena est qu'elle offre une grande flexibilité dans la façon dont vous exécutez les requêtes sans complexité supplémentaire. Lorsque vous utilisez Athena, vous pouvez interroger différents types de données, tels que CSV etJSON, dans Amazon S3 sans modifier le type de données. Vous pouvez interroger des données provenant de différentes sources, y compris extérieures AWS. Athena réduit la complexité car vous n'avez pas à gérer de serveurs. Athena lit les données directement depuis Amazon S3 sans les charger ni les modifier avant que vous n'exécutiez la requête.