Amazon Athena

Un service d'analyse sans serveur qui vous permet d'interroger directement vos données stockées dans S3 en utilisant le langage SQL standard.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'Amazon Athena ?

Imaginez que vous ayez une énorme bibliothèque de livres (vos données) et que vous souhaitiez trouver rapidement des informations spécifiques sans avoir à parcourir chaque livre. Amazon Athena est comme un assistant de bibliothèque extrêmement efficace qui peut parcourir instantanément tous vos livres et trouver exactement ce que vous cherchez.

Concrètement, Athena est un service qui vous permet d'analyser vos données stockées dans Amazon S3 en utilisant des requêtes SQL standard. Vous n'avez pas besoin de copier ou charger vos données ailleurs, et vous ne payez que pour les requêtes que vous exécutez.

Pourquoi utiliser Athena ?

Simplicité

Vous posez des questions à vos données avec le langage SQL que de nombreux professionnels connaissent déjà, sans gérer aucune infrastructure.

Rentabilité

Vous ne payez que pour les données que vous analysez, sans frais fixes ni serveurs à maintenir, ce qui réduit considérablement les coûts.

En résumé, Athena est un outil puissant qui démocratise l'analyse des données en permettant à quiconque connaissant SQL d'explorer et d'obtenir des insights à partir de grands volumes de données sans avoir à gérer une infrastructure complexe et coûteuse.

Pour les développeurs

Fonctionnement technique

Amazon Athena est un service d'analyse interactif sans serveur qui utilise Apache Presto sous le capot. Il permet d'exécuter des requêtes SQL standard sur des données stockées dans Amazon S3 sans nécessiter de chargement ou de transformation préalable.

Concepts clés et fonctionnement

Requêtes SQL

Athena prend en charge le standard SQL ANSI avec quelques extensions spécifiques à Presto. Vous pouvez utiliser les clauses SELECT, JOIN, WHERE, GROUP BY, ORDER BY et la plupart des fonctions et opérateurs SQL que vous connaissez déjà.

Exemple de requête SQL dans Athena

-- Exemple simple de requête Athena
SELECT 
  user_id,
  COUNT(*) as total_visits,
  SUM(page_views) as total_page_views,
  AVG(session_duration_seconds) as avg_session_duration
FROM 
  website_analytics.user_sessions
WHERE 
  date_of_visit BETWEEN DATE '2023-01-01' AND DATE '2023-01-31'
  AND country = 'France'
GROUP BY 
  user_id
HAVING 
  COUNT(*) > 5
ORDER BY 
  total_page_views DESC
LIMIT 10;

Tables et bases de données

Athena utilise AWS Glue Data Catalog pour stocker et gérer les métadonnées des tables. Les tables sont des définitions de schéma qui pointent vers des données stockées dans S3. Ces tables sont "externes", ce qui signifie que la suppression d'une table ne supprime pas les données sous-jacentes dans S3.

Création d'une table externe dans Athena

-- Création d'une table externe à partir de données dans S3
CREATE EXTERNAL TABLE IF NOT EXISTS sales.customer_purchases (
  transaction_id STRING,
  customer_id STRING,
  purchase_date TIMESTAMP,
  product_id STRING,
  product_name STRING,
  category STRING,
  price DECIMAL(10,2),
  quantity INT,
  total_amount DECIMAL(10,2),
  payment_method STRING
)
PARTITIONED BY (year INT, month INT)
ROW FORMAT DELIMITED
  FIELDS TERMINATED BY ','
  ESCAPED BY '\\'
  LINES TERMINATED BY '
'
STORED AS TEXTFILE
LOCATION 's3://my-company-data/sales/customer_purchases/'
TBLPROPERTIES ('has_encrypted_data'='false', 'skip.header.line.count'='1');

Formats de données

Athena prend en charge de nombreux formats de données, mais certains sont plus optimisés que d'autres pour les performances et les coûts :

Formats optimisés: Parquet et ORC (recommandés pour leurs performances et la réduction des coûts)
Formats texte: CSV, TSV, JSON, Avro
Formats de journalisation: CloudTrail, ELB, VPC Flow Logs
Formats d'archivage: Gzip, Snappy, LZO

Partitionnement

Le partitionnement divise vos données en "compartiments" selon des clés comme la date, la région ou la catégorie. Cela permet à Athena de n'analyser que les partitions pertinentes pour votre requête, réduisant ainsi la quantité de données lues et les coûts associés.

Gestion des partitions dans Athena

-- Ajout d'une nouvelle partition
ALTER TABLE sales.customer_purchases ADD PARTITION (year=2023, month=4)
  LOCATION 's3://my-company-data/sales/customer_purchases/year=2023/month=4/';

-- Vérification des partitions existantes
SHOW PARTITIONS sales.customer_purchases;

-- Suppression d'une partition
ALTER TABLE sales.customer_purchases DROP PARTITION (year=2021, month=1);

-- Mise à jour d'une partition
ALTER TABLE sales.customer_purchases PARTITION (year=2023, month=1) 
  SET LOCATION 's3://my-company-data/sales/customer_purchases/updated/year=2023/month=1/';

Requêtes complexes et analytiques

Athena supporte des fonctionnalités avancées comme les expressions de table communes (CTE), les fonctions de fenêtrage (window functions), les agrégations complexes et les jointures entre tables de différentes sources.

Requête analytique complexe avec CTE et jointures

-- Requête analytique plus complexe pour analyse des ventes
WITH customer_segments AS (
  SELECT
    customer_id,
    CASE
      WHEN SUM(total_amount) > 1000 THEN 'Premium'
      WHEN SUM(total_amount) > 500 THEN 'Standard'
      ELSE 'Basic'
    END AS segment,
    SUM(total_amount) AS total_spent,
    COUNT(DISTINCT transaction_id) AS transaction_count
  FROM
    sales.customer_purchases
  WHERE
    year = 2023
  GROUP BY
    customer_id
),

product_performance AS (
  SELECT
    cp.product_id,
    cp.product_name,
    cp.category,
    COUNT(*) AS purchase_count,
    SUM(cp.quantity) AS units_sold,
    SUM(cp.total_amount) AS revenue,
    AVG(cp.price) AS avg_price
  FROM
    sales.customer_purchases cp
  WHERE
    cp.year = 2023
  GROUP BY
    cp.product_id,
    cp.product_name,
    cp.category
)

SELECT
  pp.category,
  pp.product_name,
  pp.units_sold,
  pp.revenue,
  cs.segment AS buyer_segment,
  COUNT(DISTINCT cp.customer_id) AS unique_customers,
  SUM(cp.quantity) AS quantity_bought_by_segment
FROM
  sales.customer_purchases cp
JOIN
  customer_segments cs ON cp.customer_id = cs.customer_id
JOIN
  product_performance pp ON cp.product_id = pp.product_id
WHERE
  cp.year = 2023
  AND cp.month BETWEEN 1 AND 3
GROUP BY
  pp.category,
  pp.product_name,
  pp.units_sold,
  pp.revenue,
  cs.segment
ORDER BY
  pp.revenue DESC,
  cs.segment,
  pp.category;

Intégration programmatique

Athena s'intègre à l'AWS SDK, permettant d'exécuter des requêtes et de récupérer les résultats depuis votre code Node.js. Voici un exemple avec le SDK JavaScript :

Utilisation d'Athena avec AWS SDK JavaScript

// Utiliser Athena via le SDK AWS JavaScript v3
const { AthenaClient, StartQueryExecutionCommand, GetQueryExecutionCommand, GetQueryResultsCommand } = require('@aws-sdk/client-athena');

// Créer un client Athena
const athenaClient = new AthenaClient({ region: 'eu-west-1' });

// Configuration pour les requêtes
const config = {
  QueryString: 'SELECT * FROM sales.customer_purchases WHERE year = 2023 AND month = 3 LIMIT 10',
  QueryExecutionContext: {
    Database: 'sales'
  },
  ResultConfiguration: {
    OutputLocation: 's3://my-query-results-bucket/athena-output/',
    EncryptionConfiguration: {
      EncryptionOption: 'SSE_S3'
    }
  },
  WorkGroup: 'primary'
};

// Fonction pour exécuter une requête et attendre les résultats
async function executeQuery() {
  try {
    // Démarrer l'exécution de la requête
    const startResult = await athenaClient.send(new StartQueryExecutionCommand(config));
    const queryExecutionId = startResult.QueryExecutionId;
    console.log('Requête démarrée avec ID:', queryExecutionId);
    
    // Attendre que la requête soit terminée
    let queryStatus = '';
    do {
      await new Promise(resolve => setTimeout(resolve, 1000)); // Attendre 1 seconde
      
      const executionResponse = await athenaClient.send(new GetQueryExecutionCommand({
        QueryExecutionId: queryExecutionId
      }));
      
      queryStatus = executionResponse.QueryExecution.Status.State;
      console.log('Statut actuel:', queryStatus);
      
      // Si la requête a échoué, arrêter et afficher l'erreur
      if (queryStatus === 'FAILED') {
        throw new Error(
          'Erreur dans la requête: ' + 
          executionResponse.QueryExecution.Status.StateChangeReason
        );
      }
    } while (queryStatus === 'QUEUED' || queryStatus === 'RUNNING');
    
    // Récupérer les résultats de la requête
    if (queryStatus === 'SUCCEEDED') {
      const resultsResponse = await athenaClient.send(new GetQueryResultsCommand({
        QueryExecutionId: queryExecutionId
      }));
      
      // Traiter les résultats
      const columnInfo = resultsResponse.ResultSet.ResultSetMetadata.ColumnInfo;
      const rows = resultsResponse.ResultSet.Rows;
      
      // Extraire les en-têtes
      const headers = columnInfo.map(col => col.Name);
      
      // Extraire les données (ignorer la première ligne si elle contient les en-têtes)
      const dataRows = rows.slice(1).map(row => {
        return row.Data.map((cell, idx) => {
          return {
            name: headers[idx],
            value: cell.VarCharValue
          };
        });
      });
      
      console.log('Résultats de la requête:');
      console.log(dataRows);
      
      return dataRows;
    }
  } catch (err) {
    console.error('Erreur lors de l'exécution de la requête:', err);
    throw err;
  }
}

Optimisation des performances et des coûts

Utiliser des formats de fichier optimisés - Parquet et ORC réduisent considérablement la quantité de données scannées
Partitionner les données - Organiser les données en partitions pertinentes pour vos requêtes fréquentes
Utiliser la compression - Compresser vos fichiers réduit le volume des données scannées
Optimiser les requêtes - Sélectionner uniquement les colonnes nécessaires plutôt que d'utiliser SELECT *
Utiliser des vues - Créer des vues pour les requêtes complexes fréquemment utilisées
Limiter les résultats - Utiliser LIMIT pour les phases de développement et de test
Configurer les groupes de travail - Pour contrôler les coûts et isoler les charges de travail

Applications concrètes

Cas d'usage

Analyse de logs et d'audit

Analyse des logs d'applications, de services AWS (CloudTrail, ELB, VPC Flow Logs) pour détecter des anomalies, comprendre l'utilisation et assurer la conformité.

Analyse commerciale et marketing

Exploration des données de ventes, du comportement des clients et des indicateurs marketing pour identifier les tendances, segmenter les clients et optimiser les campagnes.

Exploration de lacs de données

Interrogation et découverte de données au sein de lacs de données S3, permettant une analyse ad hoc sans déplacement ni transformation des données.

Alimentation de tableaux de bord

Fourniture des données pour les outils de visualisation comme QuickSight, Tableau ou Power BI, permettant de créer des tableaux de bord interactifs et des rapports.