Skip to content
Learni
Voir tous les tutoriels
AWS

Comment déployer une API REST avec Amazon API Gateway en 2026

14 minINTERMEDIATE
AWSServerlessLambdaAPI GatewaySAM
Read in English

Introduction

Amazon API Gateway est un service AWS fully-managed qui permet de créer, déployer et gérer des APIs REST, HTTP ou WebSocket à l'échelle. En 2026, il intègre nativement des fonctionnalités comme l'authentification IAM, Cognito, Lambda Authorizer, et le throttling avancé pour des workloads serverless.

Pourquoi l'utiliser ? Contrairement à un serveur EC2 traditionnel, API Gateway gère automatiquement la scalabilité, la sécurité (WAF, DDoS protection via Shield), les métriques CloudWatch, et les intégrations directes avec Lambda ou d'autres services AWS. Ce tutoriel intermediate vous guide pas à pas pour déployer une API REST complète avec AWS SAM (Serverless Application Model), incluant une fonction Lambda, des routes CRUD, une autorisation basique et des tests end-to-end.

À la fin, vous aurez une API live, monitorable, avec un domaine custom optionnel. Idéal pour des microservices ou des backends mobiles. Temps estimé : 30 minutes. (128 mots)

Prérequis

  • Compte AWS actif avec permissions IAM pour API Gateway, Lambda, CloudFormation et S3 (politique AdministratorAccess pour tests).
  • AWS CLI v2 installé et configuré (aws configure).
  • AWS SAM CLI installé (voir étape suivante).
  • Node.js 18+ ou Python 3.9+ pour les handlers Lambda.
  • Outils : curl pour tests, éditeur de code (VS Code recommandé).

Installer AWS SAM CLI

terminal
# macOS avec Homebrew
brew tap aws/tap
brew install aws-sam-cli

# Linux (Amazon Linux 2023 ou Ubuntu)
curl -L https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip -o aws-sam-cli.zip
unzip aws-sam-cli.zip -d sam-installation
sudo ./sam-installation/install

# Vérifier l'installation
sam --version

Cette commande installe SAM CLI, l'outil CLI pour développer et déployer des apps serverless AWS. Elle gère la synthèse CloudFormation et les déploiements locaux/emulés. Évitez les versions obsolètes ; utilisez toujours la latest release pour compatibilité 2026 avec les nouvelles features comme Provisioned Concurrency.

Initialiser le projet SAM

Créez une app SAM de base avec un template API Gateway + Lambda. Cela génère une structure standard : template.yaml, handler Lambda, et samconfig.toml pour les déploiements.

Initialiser l'app SAM

terminal
sam init --runtime nodejs18.x --name mon-api-gateway --app-template aws-nodejs-apigateway-lambda --location ./mon-api-gateway
cd mon-api-gateway
sam build

L'initialisation crée un squelette complet avec API Gateway REST et une Lambda Node.js. sam build compile le projet en artefacts prêts pour déploiement. Piège : Assurez-vous d'être dans le bon runtime ; nodejs18.x est optimal en 2026 pour les performances V8 et les layers partagés.

Définir le template API Gateway

template.yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: API REST avec Gateway + Lambda

Globals:
  Function:
    Timeout: 30
    Runtime: nodejs18.x
    MemorySize: 512
    Environment:
      Variables:
        TABLE_NAME: !Ref MyDynamoTable

Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      Cors:
        AllowMethods: "*"
        AllowHeaders: "*"
        AllowOrigin: "*"
      Auth:
        DefaultAuthorizer: MyAuthorizer
        AddDefaultAuthorizerToCorsPreflight: false

  GetHandler:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: hello-world/
      Handler: app.lambdaHandler
      Events:
        GetResource:
          Type: Api
          Properties:
            RestApiId: !Ref MyApi
            Path: /{proxy+}
            Method: GET

  PostHandler:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: hello-world/
      Handler: app.createHandler
      Events:
        PostResource:
          Type: Api
          Properties:
            RestApiId: !Ref MyApi
            Path: /{proxy+}
            Method: POST

  MyAuthorizer:
    Type: AWS::Serverless::SimpleTable
    Properties:
      PrimaryKey:
        Name: id
        Type: String

Outputs:
  ApiGatewayUrl:
    Description: URL de l'API
    Value: !Sub https://${MyApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/

Ce template définit une API REST avec routes proxy /{proxy+} mappées à des Lambdas GET/POST. Il inclut CORS global, un authorizer basique et une table DynamoDB. Avantage : SAM gère les intégrations automatiques ; piège : Timeout 30s max pour éviter les cold starts excessifs.

Implémenter le handler Lambda

hello-world/app.js
const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();

const TABLE_NAME = process.env.TABLE_NAME;

exports.lambdaHandler = async (event) => {
  try {
    const params = {
      TableName: TABLE_NAME,
      Key: { id: event.pathParameters.proxy }
    };
    const result = await dynamodb.get(params).promise();

    const response = {
      statusCode: 200,
      headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' },
      body: JSON.stringify(result.Item || { message: 'Item non trouvé' })
    };
    return response;
  } catch (err) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: err.message })
    };
  }
};

exports.createHandler = async (event) => {
  try {
    const data = JSON.parse(event.body);
    const params = {
      TableName: TABLE_NAME,
      Item: { id: data.id, name: data.name }
    };
    await dynamodb.put(params).promise();

    return {
      statusCode: 201,
      headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' },
      body: JSON.stringify({ message: 'Item créé' })
    };
  } catch (err) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: err.message })
    };
  }
};

Ce handler gère GET (récup DynamoDB) et POST (création item). Il utilise pathParameters pour /{proxy+} et gère les erreurs avec try/catch. Pourquoi DocumentClient ? Plus simple que low-level SDK ; piège : Toujours parser event.body et ajouter CORS headers manuellement pour API Gateway.

Déployer l'API

Attention : Remplacez us-east-1 par votre région. SAM valide et déploie via CloudFormation. L'API sera live immédiatement après.

Déployer avec SAM

terminal
# Build et deploy
sam build --use-container
sam deploy --guided --stack-name mon-api-stack --region us-east-1 --capabilities CAPABILITY_IAM --resolve-s3

# Récupérer l'URL (dans les outputs CloudFormation)
aws cloudformation describe-stacks --stack-name mon-api-stack --query 'Stacks[0].Outputs[?OutputKey==`ApiGatewayUrl`].OutputValue' --output text

--use-container assure reproductibilité Docker-based. --guided configure S3 bucket auto. --capabilities CAPABILITY_IAM pour rôles Lambda. Piège : Vérifiez les outputs pour l'URL ; sans --resolve-s3, les assets ne se résolvent pas.

Tester l'API

terminal
API_URL=$(aws cloudformation describe-stacks --stack-name mon-api-stack --query 'Stacks[0].Outputs[?OutputKey==`ApiGatewayUrl`].OutputValue' --output text)

# POST créer item
curl -X POST $API_URL/test1 -H "Content-Type: application/json" -d '{"id":"test1","name":"Mon Item"}'

# GET récupérer
curl $API_URL/test1

Ces curls testent CRUD via proxy path. Remplacez API_URL par votre output réel. Succès : 200/201 avec JSON. Piège : Sans -H Content-Type, parse JSON échoue ; vérifiez CloudWatch Logs pour debug Lambda.

Nettoyage des ressources

terminal
sam delete --stack-name mon-api-stack --region us-east-1
aws cloudformation delete-stack --stack-name mon-api-stack --region us-east-1

Supprime stack CloudFormation et ressources associées (API, Lambda, Dynamo). Essentiel pour éviter coûts. SAM delete est plus sûr car il gère les dépendances ; confirme avec --no-prompt en CI/CD.

Bonnes pratiques

  • Utilisez des Authorizers avancés : Intégrez Cognito ou Lambda Authorizer pour JWT/OAuth, pas IAM seul en prod.
  • Activez WAF et throttling : Ajoutez AWS::WAFv2::WebACL à votre template pour DDoS et rate limiting.
  • Logging et monitoring : Enable Access Logs sur API Gateway vers CloudWatch Logs ; utilisez X-Ray pour tracing.
  • Custom Domain + ACM : Associez un domaine via Route53 et certificat gratuit ACM.
  • CI/CD avec SAM Pipelines : Automatisez builds/deploy avec GitHub Actions ou CodePipeline.

Erreurs courantes à éviter

  • Cold starts excessifs : Provisionnez concurrency sur Lambda ou utilisez SnapStart (pour Java/Rust).
  • CORS mal configuré : Toujours définir Cors dans SAM et headers dans handler ; testez preflight OPTIONS.
  • Permissions manquantes : Lambda doit avoir dynamodb:* sur la table ; SAM génère auto mais vérifiez en multi-region.
  • Proxy path trop permissif : Limitez routes spécifiques au lieu de /{proxy+} pour sécurité.

Pour aller plus loin

  • Documentation officielle : AWS API Gateway.
  • Tutoriel avancé WebSocket : ici.
  • Formations complètes : Découvrez nos formations AWS Learni pour certification Solutions Architect.
  • Outils : AWS CDK pour IaC TypeScript, ou Serverless Framework comme alternative SAM.