Amazon Batch

Un service de traitement par lots entièrement géré pour exécuter efficacement vos charges de travail de calcul intensif sans gérer une infrastructure complexe.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'Amazon Batch ?

Imaginez que vous ayez des milliers de photos à redimensionner, des centaines de vidéos à traiter, ou d'énormes quantités de données à analyser. Ces tâches peuvent prendre des heures, voire des jours, si vous les traitez sur un seul ordinateur.

Amazon Batch est comme une usine automatique capable de diviser ce travail en petites tâches, de les distribuer à des centaines d'ordinateurs pour les traiter en parallèle, puis de rassembler les résultats. Le tout sans que vous ayez à gérer ces ordinateurs.

Pourquoi utiliser Batch ?

Efficacité

Traite rapidement des charges de travail importantes en exécutant des tâches en parallèle sur plusieurs machines.

Optimisation des coûts

Paie uniquement pour les ressources utilisées et profité d'options d'optimisation des coûts comme les instances Spot d'EC2.

En résumé, Amazon Batch est comme avoir une équipe d'assistants virtuels qui travaillent pour vous en parallèle. Cela vous permet de réaliser des travaux qui prendraient normalement des semaines en quelques heures seulement, sans avoir à gérer ou configurer des serveurs.

Pour les développeurs

Fonctionnement technique

Amazon Batch est un service entièrement géré qui permet d'exécuter des charges de travail de calcul par lots en parallèle sur AWS. Il s'occupe du provisionnement dynamique des ressources et de la planification des jobs en fonction de leurs exigences.

Composants principaux

Définitions de jobs

Les définitions de jobs spécifient comment les jobs sont exécutés. Elles définissent les conteneurs Docker à exécuter, le nombre de vCPUs et la mémoire nécessaires, les variables d'environnement, les volumes à monter, etc.

Définition d'un job Batch avec AWS SDK

// Définition d'un job Batch via AWS SDK JavaScript
const { BatchClient, RegisterJobDefinitionCommand } = require('@aws-sdk/client-batch');

// Créer un client Batch
const batchClient = new BatchClient({ region: 'eu-west-1' });

async function registerJobDefinition() {
  const params = {
    jobDefinitionName: 'video-processing-job',
    type: 'container',
    containerProperties: {
      image: '123456789012.dkr.ecr.eu-west-1.amazonaws.com/video-processor:latest',
      vcpus: 2,
      memory: 2048,
      command: [
        'node',
        'process-video.js',
        'Ref::inputFile',
        'Ref::outputBucket'
      ],
      jobRoleArn: 'arn:aws:iam::123456789012:role/BatchJobRole',
      environment: [
        {
          name: 'LOG_LEVEL',
          value: 'INFO'
        },
        {
          name: 'PROCESSING_MODE',
          value: 'HD'
        }
      ],
      volumes: [
        {
          name: 'temp',
          host: {
            sourcePath: '/tmp'
          }
        }
      ],
      mountPoints: [
        {
          containerPath: '/temp',
          readOnly: false,
          sourceVolume: 'temp'
        }
      ],
      privileged: false,
      ulimits: [
        {
          hardLimit: 1024,
          name: 'nofile',
          softLimit: 1024
        }
      ],
      resourceRequirements: [
        {
          type: 'GPU',
          value: '1'
        }
      ]
    },
    retryStrategy: {
      attempts: 3
    },
    timeout: {
      attemptDurationSeconds: 3600 // 1 heure maximum par tentative
    },
    parameters: {
      'inputFile': '',
      'outputBucket': ''
    },
    tags: {
      Department: 'MediaProcessing',
      Project: 'VideoTranscoding'
    }
  };

  try {
    const data = await batchClient.send(new RegisterJobDefinitionCommand(params));
    console.log('Définition de job enregistrée:', data.jobDefinitionName, 'revision:', data.revision);
    return data;
  } catch (err) {
    console.error('Erreur lors de l'enregistrement de la définition de job:', err);
    throw err;
  }
}

Environnements de calcul

Les environnements de calcul définissent les ressources de calcul utilisées pour exécuter les jobs. Ils peuvent être gérés par AWS (MANAGED) ou par vous-même (UNMANAGED). Ils peuvent utiliser des instances EC2, Fargate, ou du calcul local.

Création d'un environnement de calcul Batch

// Création d'un environnement de calcul Batch via AWS SDK JavaScript
const { BatchClient, CreateComputeEnvironmentCommand } = require('@aws-sdk/client-batch');

// Créer un client Batch
const batchClient = new BatchClient({ region: 'eu-west-1' });

async function createComputeEnvironment() {
  const params = {
    computeEnvironmentName: 'video-processing-env',
    type: 'MANAGED',
    state: 'ENABLED',
    computeResources: {
      type: 'SPOT', // Utilisation des instances Spot pour économiser sur les coûts
      allocationStrategy: 'SPOT_CAPACITY_OPTIMIZED',
      minvCpus: 0,  // Dimensionnement à zéro quand aucun travail n'est en cours
      desiredvCpus: 0,
      maxvCpus: 64, // Limite maximale de ressources
      instanceTypes: [
        'c5.large', 'c5.xlarge', 'c5.2xlarge', // Famille d'instances optimisée pour le calcul
        'g4dn.xlarge', 'g4dn.2xlarge'         // Instances avec GPU pour le traitement vidéo
      ],
      subnets: [
        'subnet-abcdef12',
        'subnet-34567890'
      ],
      securityGroupIds: [
        'sg-abcdef12'
      ],
      instanceRole: 'arn:aws:iam::123456789012:instance-profile/ecsInstanceRole',
      bidPercentage: 80, // Offre 80% du prix à la demande pour les instances Spot
      spotIamFleetRole: 'arn:aws:iam::123456789012:role/AmazonEC2SpotFleetRole',
      ec2KeyPair: 'my-key-pair',
      tags: {
        'Department': 'MediaProcessing'
      },
      launchTemplate: {
        launchTemplateId: 'lt-0123456789abcdef0',
        version: '$Default'
      }
    },
    serviceRole: 'arn:aws:iam::123456789012:role/service-role/AWSBatchServiceRole',
    tags: {
      Project: 'VideoTranscoding',
      Environment: 'Production'
    }
  };

  try {
    const data = await batchClient.send(new CreateComputeEnvironmentCommand(params));
    console.log('Environnement de calcul créé:', data.computeEnvironmentName, 'ARN:', data.computeEnvironmentArn);
    return data;
  } catch (err) {
    console.error('Erreur lors de la création de l'environnement de calcul:', err);
    throw err;
  }
}

Files d'attente de jobs

Les files d'attente sont des files où les jobs sont placés avant d'être exécutés. Elles peuvent être reliées à plusieurs environnements de calcul avec des priorités différentes. Quand un job est soumis à une file d'attente, le service Batch le planifie sur l'environnement de calcul approprié.

Jobs

Les jobs sont les unités de travail soumises à une file d'attente. Chaque job référence une définition de job et peut inclure des paramètres spécifiques à cette exécution.

Soumission d'un job Batch

// Soumission d'un job Batch via AWS SDK JavaScript
const { BatchClient, SubmitJobCommand } = require('@aws-sdk/client-batch');

// Créer un client Batch
const batchClient = new BatchClient({ region: 'eu-west-1' });

async function submitJob() {
  const params = {
    jobName: 'process-wedding-video-12345',
    jobQueue: 'video-processing-queue',
    jobDefinition: 'video-processing-job:3', // Nom et révision de la définition
    parameters: {
      'inputFile': 's3://raw-videos/wedding-footage-12345.mp4',
      'outputBucket': 'processed-videos'
    },
    containerOverrides: {
      vcpus: 4,     // Remplacer les vCPUs spécifiés dans la définition du job
      memory: 4096, // Remplacer la mémoire spécifiée dans la définition du job
      environment: [
        {
          name: 'PROCESSING_MODE',
          value: '4K' // Remplacer la valeur par défaut de HD à 4K
        },
        {
          name: 'PRIORITY',
          value: 'HIGH'
        }
      ]
    },
    dependsOn: [
      {
        jobId: 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111', // ID d'un job dont celui-ci dépend
        type: 'SEQUENTIAL' // N'exécuter ce job qu'après la réussite du job dépendant
      }
    ],
    timeout: {
      attemptDurationSeconds: 7200 // 2 heures maximum
    },
    tags: {
      'Customer': 'Smith-Wedding',
      'OrderId': '12345'
    }
  };

  try {
    const data = await batchClient.send(new SubmitJobCommand(params));
    console.log('Job soumis avec succès, Job ID:', data.jobId);
    return data.jobId;
  } catch (err) {
    console.error('Erreur lors de la soumission du job:', err);
    throw err;
  }
}

Jobs Array

Les jobs array sont un moyen d'exécuter de nombreuses copies d'un même job en parallèle, chacune avec un index différent. C'est idéal pour traiter plusieurs fichiers stockés dans S3 ou ensembles de données similaires en parallèle.

Soumission d'un job Array pour le traitement parallèle

// Soumission d'un job Array avec AWS Batch (traitement parallèle)
const { BatchClient, SubmitJobCommand } = require('@aws-sdk/client-batch');

// Créer un client Batch
const batchClient = new BatchClient({ region: 'eu-west-1' });

async function submitArrayJob() {
  const params = {
    jobName: 'image-thumbnail-generator',
    jobQueue: 'image-processing-queue',
    jobDefinition: 'thumbnail-generator-job',
    arrayProperties: {
      size: 1000,  // Créer 1000 tâches parallèles
      // Facultatif: limiter la parallélisation pour éviter de surcharger les ressources
      // En limitant à 100, seulement 100 tâches seront exécutées simultanément
      // Les autres attendront dans la file d'attente
      dependsOn: 100
    },
    parameters: {
      'inputBucket': 's3://raw-images/',
      'outputBucket': 's3://thumbnails/',
      'imagesList': 's3://image-processing-config/batch1/images.json'
    },
    containerOverrides: {
      // La variable d'environnement AWS_BATCH_JOB_ARRAY_INDEX est automatiquement fournie
      // à chaque tâche avec un index unique (0-999 dans cet exemple)
      command: [
        "node", 
        "process-image.js", 
        "--index", 
        "Ref::AWS_BATCH_JOB_ARRAY_INDEX"
      ]
    }
  };

  try {
    const data = await batchClient.send(new SubmitJobCommand(params));
    console.log('Job Array soumis avec succès, Job ID:', data.jobId);
    return data.jobId;
  } catch (err) {
    console.error('Erreur lors de la soumission du job array:', err);
    throw err;
  }
}

Infrastructure as Code

AWS Batch s'intègre parfaitement avec les outils d'infrastructure as code comme AWS CloudFormation ou AWS CDK.

Template CloudFormation pour AWS Batch

AWSTemplateFormatVersion: '2010-09-09'
Description: 'Infrastructure AWS Batch pour le traitement vidéo'

Resources:
  # Rôle IAM pour le service AWS Batch
  BatchServiceRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: batch.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole'
  
  # Rôle IAM pour les instances EC2
  EC2Role:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: ec2.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role'
        - 'arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess'
  
  # Profil d'instance pour associer le rôle IAM aux instances EC2
  EC2InstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Roles:
        - !Ref EC2Role
  
  # Environnement de calcul Batch
  BatchComputeEnvironment:
    Type: AWS::Batch::ComputeEnvironment
    Properties:
      Type: MANAGED
      ServiceRole: !GetAtt BatchServiceRole.Arn
      State: ENABLED
      ComputeResources:
        Type: SPOT
        MaxvCpus: 256
        MinvCpus: 0
        DesiredvCpus: 0
        InstanceTypes:
          - optimal
        Subnets:
          - !Ref PublicSubnet1
          - !Ref PublicSubnet2
        SecurityGroupIds:
          - !Ref BatchSecurityGroup
        InstanceRole: !Ref EC2InstanceProfile
        BidPercentage: 70
        SpotIamFleetRole: !GetAtt SpotFleetRole.Arn
  
  # File d'attente des jobs Batch
  BatchJobQueue:
    Type: AWS::Batch::JobQueue
    Properties:
      Priority: 1
      State: ENABLED
      ComputeEnvironmentOrder:
        - Order: 1
          ComputeEnvironment: !Ref BatchComputeEnvironment
  
  # Définition du job Batch pour le traitement vidéo
  VideoProcessingJobDefinition:
    Type: AWS::Batch::JobDefinition
    Properties:
      Type: container
      JobDefinitionName: video-transcoding-job
      RetryStrategy:
        Attempts: 3
      Timeout:
        AttemptDurationSeconds: 3600
      ContainerProperties:
        Image: !Sub "${AWS::AccountId}.dkr.ecr.${AWS::Region}.amazonaws.com/video-processor:latest"
        Vcpus: 4
        Memory: 16384
        Command:
          - 'node'
          - 'process-video.js'
          - 'Ref::inputFile'
          - 'Ref::outputFormat'
          - 'Ref::outputBucket'
        JobRoleArn: !GetAtt BatchJobRole.Arn
        Environment:
          - Name: LOG_LEVEL
            Value: INFO
        MountPoints:
          - ContainerPath: /tmp
            ReadOnly: false
            SourceVolume: tmp
        Volumes:
          - Name: tmp
            Host:
              SourcePath: /tmp

Outputs:
  JobQueueArn:
    Description: ARN de la file d'attente des jobs Batch
    Value: !Ref BatchJobQueue
  JobDefinitionArn:
    Description: ARN de la définition de job de traitement vidéo
    Value: !Ref VideoProcessingJobDefinition

Caractéristiques avancées

Multi-nœud parallèle - Prise en charge des jobs parallèles multi-nœuds pour les charges de travail fortement couplées
GPU - Support des instances équipées de GPU pour le calcul intensif comme l'apprentissage automatique ou le rendu 3D
Planification automatique - Sélection des instances et ajustement automatique des ressources en fonction des besoins
Dépendances entre jobs - Définition d'une séquence de jobs avec des dépendances
Politiques de nouvelle tentative - Configuration des politiques de nouvelle tentative pour les jobs qui échouent
Intégration à AWS Lambda et EventBridge - Déclenchement de jobs Batch par des événements