Un guide pour créer une API sans serveur AWS et un pipeline CICD

Aperçu

Cet article démontre le développement d'une API sans serveur utilisant les services AWS et établit un pipeline d'intégration continue/déploiement continu (CICD) dans l'environnement AWS.

Partie 1 : explore la création d'une fonction Lambda pour gérer les requêtes de la passerelle API et conserver les données dans DynamoDB à l'aide du modèle d'application sans serveur.

Partie 2 : détaille les étapes nécessaires pour configurer un référentiel CodeCommit dans AWS et configurer un pipeline CICD qui lance automatiquement un processus de génération lors de la soumission de nouvelles modifications au référentiel.

Conditions préalables

Pour ce projet, vous aurez besoin d'un compte AWS (l'offre gratuite est suffisante). Les composants AWS suivants seront utilisés :

• Passerelle API AWS
• AWS Lambda
• AWS DynamoDB
• AWS CodeCommit
• AWS CodeBuild
• AWS CodePipeline
• AWS S3
• Divers - CloudWatch, IAM, etc.

Assurez-vous que votre environnement de développement local est configuré comme suit :

1. Installer AWS CLI : suivez le guide ici pour installer l'AWS Command Line Interface.

   
   

2. Installez AWS SAM (Serverless Application Model) : installez SAM CLI en suivant les instructions ici .

   
   

3. Choisissez un IDE : utilisez IntelliJ ou un IDE similaire pour le développement. Je préfère IntelliJ

   
   

4. Maven pour l'empaquetage : assurez-vous que Maven est installé pour empaqueter votre application.

   
   

5. Facultatif : Docker (si vous devez tester les fonctions Lambda localement) : installez Docker si vous prévoyez de tester les fonctions Lambda localement.

Ces outils et composants constitueront la base du projet.

Partie 1 : Développement

Dans cette section, nous verrons le processus de création d'un projet de démarrage à l'aide d'AWS SAM, y compris la réalisation de la classe de gestionnaire, la création, le déploiement sur AWS et la réalisation de tests à l'aide de Postman.

Configuration de l'environnement

1. Configuration AWS :

   Accédez à la console AWS à l' adresse https://aws.amazon.com/console/ , connectez-vous à l'aide de vos informations d'identification d'utilisateur administrateur.

   1. Créer un utilisateur dans IAM :
      • Dans IAM, créez un utilisateur dédié au développement local et à l'utilisation CLI/SAM.
   2. Créez une table DynamoDB :
      • Nom : "utilisateurs", Clé primaire : "id" (Type : chaîne)

2. Configurez l'AWS CLI sur la machine locale :

   • Ouvrez un terminal et exécutez $ aws configure
   • Fournissez les clés d'accès pour l'utilisateur IAM créé précédemment ainsi que d'autres valeurs par défaut

3. Initialisez un projet à l'aide d'AWS Serverless Application Model (SAM) :

   • Ouvrez votre terminal et exécutez $ sam init
   • Choisissez le modèle de démarrage rapide AWS.
   • Optez pour un exemple « Hello World ».
   • Sélectionnez Java 11 ou 17, type de package zip et utilisez Maven comme gestionnaire de dépendances.
   • Activez la journalisation et la surveillance avec CloudWatch et XRay.

4. Renommer le projet : renommez le projet selon votre nom préféré.

5. Ouvrez le projet dans IntelliJ : Lancez IntelliJ et ouvrez le projet.

6. Ajouter des dépendances à pom.xml :

   • Ajoutez les dépendances nécessaires au fichier pom.xml . Il vous suffit d'ajouter DynamoDB, car les autres dépendances seront automatiquement incluses par SAM.

      <dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-lambda-java-core</artifactId> <version>1.2.2</version> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-lambda-java-events</artifactId> <version>3.11.0</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-dynamodb</artifactId> <version>1.12.573</version> </dependency> </dependencies>

     
     

Écrire la classe du gestionnaire

Pour la fonction lambda, modifiez la classe de gestionnaire générée automatiquement par sam et ajoutez le code suivant : c'est un code simple, et pour de vrais projets, vous souhaiterez peut-être utiliser un code plus modulaire.

 public class UserRequestHandler implements RequestHandler<Map<String,String>, Map<String,String>> { private AmazonDynamoDB amazonDynamoDB; private String DYNAMODB_TABLE_NAME = "users"; private Regions REGION = Regions.US_EAST_1; @Override public Map<String,String> handleRequest(Map<String,String> input, Context context) { this.initDynamoDbClient(); LambdaLogger logger = context.getLogger(); logger.log("Input payload:" + input.toString()); String userId = UUID.randomUUID().toString(); String firstName= input.get("firstName"); String lastName= input.get("lastName"); Map<String, AttributeValue> attributesMap = new HashMap<>(); attributesMap.put("id", new AttributeValue(userId)); attributesMap.put("firstName", new AttributeValue(firstName)); attributesMap.put("lastName", new AttributeValue(lastName)); logger.log(attributesMap.toString()); amazonDynamoDB.putItem(DYNAMODB_TABLE_NAME, attributesMap); Map<String, String> response = new HashMap<>(); response.put("id", userId); response.put("firstName", firstName); response.put("lastName", lastName); return response; } private void initDynamoDbClient() { this.amazonDynamoDB = AmazonDynamoDBClientBuilder.standard() .withRegion(REGION) .build(); } }

Mettre à jour le fichier de modèle SAM

Le fichier modèle SAM joue un rôle central dans la création et le déploiement des modifications sur AWS. Mettez à jour le fichier du projet. Les éléments clés sur lesquels se concentrer dans ce fichier sont les noms des fonctions Lambda et les points de terminaison API Gateway. Ils sont au cœur des fonctionnalités de votre application sans serveur.

 AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: > pc-aws-user-api Sample SAM Template for pc-aws-user-api # More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst Globals: Function: Timeout: 20 MemorySize: 128 Tracing: Active Api: TracingEnabled: true Resources: UserRequestHandlerLambdaFunction: Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction Properties: CodeUri: PcAwsUsersApi Handler: com.pc.aws.users.UserRequestHandler::handleRequest Runtime: java11 Architectures: - x86_64 MemorySize: 512 Environment: # More info about Env Vars: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#environment-object Variables: PARAM1: VALUE JAVA_TOOL_OPTIONS: -XX:+TieredCompilation -XX:TieredStopAtLevel=1 # More info about tiered compilation https://aws.amazon.com/blogs/compute/optimizing-aws-lambda-function-performance-for-java/ Events: PcUsers: Type: Api # More info about API Event Source: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api Properties: Path: /users Method: post ApplicationResourceGroup: Type: AWS::ResourceGroups::Group Properties: Name: Fn::Sub: ApplicationInsights-SAM-${AWS::StackName} ResourceQuery: Type: CLOUDFORMATION_STACK_1_0 ApplicationInsightsMonitoring: Type: AWS::ApplicationInsights::Application Properties: ResourceGroupName: Ref: ApplicationResourceGroup AutoConfigurationEnabled: 'true' Outputs: # ServerlessRestApi is an implicit API created out of Events key under Serverless::Function # Find out more about other implicit resources you can reference within SAM # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api PcAwsUsersApi: Description: API Gateway endpoint URL for Prod stage Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/users/" UserRequestHandlerLambdaFunction: Description: Lambda Function ARN Value: !GetAtt UserRequestHandlerLambdaFunction.Arn UserRequestHandlerLambdaFunctionIamRole: Description: Implicit IAM Role created Value: !GetAtt UserRequestHandlerLambdaFunctionRole.Arn

Créer et déployer du code à l'aide de SAM

Dans IntelliJ, ouvrez le terminal et exécutez les commandes suivantes :

$ sam build

$ sam deploy –guided

Lorsque vous y êtes invité, fournissez le nom de la pile comme « PcAwsUsersApi » et choisissez les options par défaut.

Le résultat présentera la pile CloudFormation qui a été créée et fournira également le point de terminaison API Gateway.

Testez l'API

Avant de tester l'API, accordez à DynamoDB l'accès au rôle Lambda créé par SAM.

• Ouvrez la fonction Lambda dans la console AWS.

• Accédez à « Autorisations » et localisez le nom du rôle.

• Ajoutez l'autorisation « DynamoDBFullAccess » à ce rôle.

Cette étape garantit que la fonction Lambda dispose des autorisations nécessaires pour interagir avec DynamoDB.

Accédez à API Gateway, puis suivez ces étapes pour obtenir l'URL de votre service :

1. Accédez à API Gateway dans la console AWS.

2. Sélectionnez votre API.

3. Dans la barre latérale gauche, cliquez sur « Étapes ».

4. Sous « Étapes », sélectionnez l'étape « Prod ».

5. Dans la section Stage Editor, vous trouverez « Invoke URL ». Copiez cette URL.

   
   

• Lancez l'application Postman.
• Créer une requête POST : configurez une nouvelle requête avec les détails suivants :
  • Méthode : POST
  • URL : collez l'URL du point de terminaison API Gateway obtenue précédemment.
• Définir les en-têtes : ajoutez tous les en-têtes nécessaires (par exemple, Content-Type: application/json ).

• Ajouter un corps de demande : créez un objet JSON représentant les données utilisateur que vous souhaitez envoyer dans la demande. Il s'agit des données que vous prévoyez de stocker dans DynamoDB.

Partie II Mettre en œuvre le pipeline CICD

Dans cette section, nous montrerons comment créer un pipeline CICD à l'aide d'AWS CodeCommit, CodeBuild et CodePipeline. Le pipeline lancera un processus de construction qui récupère le code du référentiel, le construit à l'aide du fichier de construction et déclenche CloudFormation pour créer la pile.

Créer un référentiel CodeCommit

Connectez-vous à AWS et recherchez le service CodeCommit.

Créez un nouveau référentiel dans AWS CodeCommit pour stocker le code source de votre projet.

Valider le code dans le référentiel

Dans IntelliJ, ouvrez le terminal et entrez les commandes suivantes pour valider le code créé à l'étape I

 $ git init → This initialize local git $ git add . → This will stage files $ git commit -m "commit to CodeCommit"

Transférer les modifications au dépôt distant

Copiez l'URL du dépôt CodeCommit à partir de la console AWS.

 $ git remote add origin <repo URL> $ git push --set-upstream origin master --> This will prompt for user/password

Créer un projet AWS CodeBuild

Configurez un projet CodeBuild qui spécifie comment générer votre application. Cela inclut la définition des environnements de construction, des commandes de construction et des dépendances.

• Créez un compartiment S3 pour stocker les fichiers de build.

• Recherchez AWS Code Build, créez un nouveau projet et fournissez CodeCommit comme source de code et S3 pour le stockage des artefacts.

Pour configurer CodeBuild, vous devrez créer un fichier de spécification de build nommé buildspec.yml dans le répertoire de votre projet. Ce fichier contiendra les commandes de construction et les instructions pour CodeBuild.

Vous pouvez vous référer à la documentation officielle ici pour obtenir des instructions détaillées sur la création d'un fichier buildspec.yml .

 version: 0.2 phases: install: runtime-versions: java: corretto11 pre_build: commands: - echo Nothing to do in the pre_build phase... build: commands: - echo Build started on `date` - sam build - sam package --output-template-file pcoutputtemplate.yaml --s3-bucket com-appsdev-pc-001 post_build: commands: - echo Build completed on `date` artifacts: files: - pcoutputtemplate.yaml

Poussez le nouveau fichier vers le référentiel depuis le local.

Après cela, vous pouvez créer le projet pour voir si le code est extrait du dépôt et si les artefacts sont créés.

Créer un CodePipeline

• Créez un nouveau pipeline dans AWS CodePipeline.

• Connectez le pipeline à votre référentiel CodeCommit en tant que source.

• Configurez le pipeline pour utiliser CodeBuild comme étape de génération.

• Ajoutez une étape de déploiement pour déclencher CloudFormation à l'aide du modèle que vous avez créé.

Le pipeline créera et déploiera automatiquement le code basé sur le commit git.

Testez le pipeline

• Ouvrez votre projet dans IntelliJ.

• Apportez une petite modification à l'un de vos fichiers, par exemple, ajoutez une autre ligne de journalisation.

• Validez la modification dans votre référentiel Git local.

• Envoyez la validation vers le référentiel CodeCommit.

 $ git branch CR01 $ git checkout CR01 $ git add . $ git commit -m “CR01” $ git push --set-upstream origin CR01 You cand also create a pull request in aws code commit, just for simplicity I am merging from local $ git checkout master $ git merge --ff-only CR01 $ git push

• Accédez à la console AWS CodePipeline.

• Vous devriez voir le pipeline démarrer automatiquement. Il extraira le dernier code du référentiel, construira le projet à l'aide de CodeBuild et le déploiera à l'aide de CloudFormation.

• Surveillez la progression dans le tableau de bord CodePipeline.

Cela simulera le processus de modification de votre code, de transmission vers le référentiel et de déclenchement et de déploiement automatiques du pipeline CICD par le code mis à jour.

En exploitant AWS API Gateway, Lambda, DynamoDB, CodeCommit, CodeBuild et CodePipeline, l'article montre comment concevoir un processus de déploiement résilient et automatisé.

Merci pour la lecture. Que vos efforts sans serveur soient couronnés de succès et d’innovation !