Ein Leitfaden zum Aufbau einer serverlosen AWS-API und CICD-Pipeline

Überblick

Dieser Artikel demonstriert die Entwicklung einer serverlosen API unter Verwendung von AWS-Diensten und richtet eine CICD-Pipeline (Continuous Integration/Continuous Deployment) innerhalb der AWS-Umgebung ein.

Teil 1: Untersucht die Erstellung einer Lambda-Funktion, um Anfragen vom API-Gateway zu verarbeiten und die Daten in DynamoDB mithilfe des serverlosen Anwendungsmodells beizubehalten.

Teil 2: Beschreibt die notwendigen Schritte zum Konfigurieren eines CodeCommit-Repositorys in AWS und zum Einrichten einer CICD-Pipeline, die bei der Übermittlung neuer Änderungen an das Repository automatisch einen Build-Prozess initiiert.

Voraussetzungen

Für dieses Projekt benötigen Sie ein AWS-Konto (kostenloses Kontingent ist ausreichend). Die folgenden AWS-Komponenten werden verwendet:

• AWS API Gateway
• AWS Lambda
• AWS DynamoDB
• AWS CodeCommit
• AWS CodeBuild
• AWS CodePipeline
• AWS S3
• Sonstiges – CloudWatch, IAM usw

Stellen Sie sicher, dass Ihre lokale Entwicklungsumgebung wie folgt eingerichtet ist:

1. AWS CLI installieren : Befolgen Sie die Anleitung hier, um die AWS Command Line Interface zu installieren.

   
   

2. Installieren Sie AWS SAM (Serverless Application Model) : Installieren Sie SAM CLI, indem Sie den Anweisungen hier folgen.

   
   

3. Wählen Sie eine IDE : Verwenden Sie IntelliJ oder eine ähnliche IDE für die Entwicklung. Ich bevorzuge IntelliJ

   
   

4. Maven zum Verpacken : Stellen Sie sicher, dass Sie Maven zum Verpacken Ihrer Anwendung installiert haben.

   
   

5. Optional: Docker (wenn Sie Lambda-Funktionen lokal testen müssen): Installieren Sie Docker, wenn Sie Lambda-Funktionen lokal testen möchten.

Diese Tools und Komponenten bilden die Grundlage des Projekts.

Teil 1: Entwicklung

In diesem Abschnitt sehen wir uns den Prozess der Erstellung eines Starterprojekts mit AWS SAM an, einschließlich der Fertigstellung der Handler-Klasse, der Erstellung, der Bereitstellung in AWS und der Durchführung von Tests mit Postman

Umgebungseinrichtung

1. AWS-Setup :

   Gehen Sie zur AWS-Konsole unter https://aws.amazon.com/console/ und melden Sie sich mit Ihren Administrator-Benutzeranmeldeinformationen an.

   1. Erstellen Sie einen Benutzer in IAM :
      • Erstellen Sie in IAM einen Benutzer, der für die lokale Entwicklung und die CLI/SAM-Nutzung vorgesehen ist.
   2. Erstellen Sie eine DynamoDB-Tabelle :
      • Name: „users“, Primärschlüssel: „id“ (Typ: String)

2. Konfigurieren Sie AWS CLI auf dem lokalen Computer :

   • Öffnen Sie ein Terminal und führen Sie $ aws configure aus
   • Geben Sie die Zugriffsschlüssel für den zuvor erstellten IAM-Benutzer und andere Standardwerte an

3. Initialisieren Sie ein Projekt mit AWS Serverless Application Model (SAM) :

   • Öffnen Sie Ihr Terminal und führen Sie $ sam init aus
   • Wählen Sie die AWS-Schnellstartvorlage.
   • Entscheiden Sie sich für ein „Hello World“-Beispiel.
   • Wählen Sie Java 11 oder 17, den Pakettyp „zip“ und verwenden Sie Maven als Abhängigkeitsmanager.
   • Aktivieren Sie Protokollierung und Überwachung mit CloudWatch und XRay.

4. Benennen Sie das Projekt um : Benennen Sie das Projekt in Ihren bevorzugten Namen um.

5. Öffnen Sie das Projekt in IntelliJ : Starten Sie IntelliJ und öffnen Sie das Projekt.

6. Abhängigkeiten zu pom.xml hinzufügen :

   • Fügen Sie die erforderlichen Abhängigkeiten zur Datei pom.xml hinzu. Sie müssen nur DynamoDB hinzufügen, da andere Abhängigkeiten automatisch von SAM einbezogen werden.

      <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>

     
     

Schreiben Sie die Handler-Klasse

Bearbeiten Sie für die Lambda-Funktion die von Sam automatisch generierte Handler-Klasse und fügen Sie den folgenden Code hinzu; Dies ist ein einfacher Code, und für echte Projekte möchten Sie möglicherweise modulareren Code verwenden.

 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(); } }

SAM-Vorlagendatei aktualisieren

Die SAM-Vorlagendatei spielt eine zentrale Rolle beim Erstellen und Bereitstellen von Änderungen in AWS. Aktualisieren Sie die Datei für das Projekt. Die Schlüsselelemente, auf die man sich in dieser Datei konzentrieren sollte, sind die Lambda-Funktionsnamen und die API-Gateway-Endpunkte. Sie sind von zentraler Bedeutung für die Funktionalität Ihrer serverlosen Anwendung.

 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

Erstellen und Bereitstellen von Code mit SAM

Öffnen Sie in IntelliJ das Terminal und führen Sie die folgenden Befehle aus:

$ sam build

$ sam deploy –guided

Geben Sie bei Aufforderung den Stack-Namen „PcAwsUsersApi“ ein und wählen Sie die Standardoptionen aus.

Die Ausgabe zeigt den erstellten CloudFormation-Stack und stellt auch den API-Gateway-Endpunkt bereit.

Testen Sie die API

Gewähren Sie DynamoDB vor dem Testen der API Zugriff auf die von SAM erstellte Lambda-Rolle.

• Öffnen Sie die Lambda-Funktion in der AWS-Konsole.

• Navigieren Sie zu „Berechtigungen“ und suchen Sie den Rollennamen.

• Fügen Sie dieser Rolle die Berechtigung „DynamoDBFullAccess“ hinzu.

Dieser Schritt stellt sicher, dass die Lambda-Funktion über die erforderlichen Berechtigungen für die Interaktion mit DynamoDB verfügt.

Navigieren Sie zu API Gateway und führen Sie dann die folgenden Schritte aus, um die URL für Ihren Dienst abzurufen:

1. Gehen Sie in der AWS-Konsole zu API Gateway.

2. Wählen Sie Ihre API aus.

3. Klicken Sie in der linken Seitenleiste auf „Stufen“.

4. Wählen Sie unter „Stufen“ die Stufe „Prod“ aus.

5. Im Abschnitt „Bühneneditor“ finden Sie die „Aufruf-URL“. Kopieren Sie diese URL.

   
   

• Starten Sie die Postman-Anwendung.
• Erstellen Sie eine POST-Anfrage: Richten Sie eine neue Anfrage mit den folgenden Details ein:
  • Methode: POST
  • URL: Fügen Sie die zuvor erhaltene API Gateway-Endpunkt-URL ein.
• Header festlegen: Fügen Sie alle erforderlichen Header hinzu (z. B. Content-Type: application/json ).

• Anfragetext hinzufügen: Erstellen Sie ein JSON-Objekt, das die Benutzerdaten darstellt, die Sie in der Anfrage senden möchten. Dies wären die Daten, von denen Sie erwarten, dass sie in DynamoDB gespeichert werden.

Teil II CICD-Pipeline implementieren

In diesem Abschnitt zeigen wir, wie Sie eine CICD-Pipeline mit AWS CodeCommit, CodeBuild und CodePipeline erstellen. Die Pipeline initiiert einen Build-Prozess, der Code aus dem Repository abruft, ihn mithilfe der Build-Datei erstellt und CloudFormation dazu veranlasst, den Stack zu erstellen.

Erstellen Sie ein CodeCommit-Repository

Melden Sie sich bei AWS an und suchen Sie nach dem CodeCommit-Dienst.

Erstellen Sie in AWS CodeCommit ein neues Repository, um den Quellcode Ihres Projekts zu speichern.

Code ins Repository übertragen

Öffnen Sie in IntelliJ das Terminal und geben Sie die folgenden Befehle ein, um den in Schritt I erstellten Code zu übernehmen

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

Push-Änderungen an das Remote-Repo übertragen

Kopieren Sie die CodeCommit-Repo-URL aus der AWS-Konsole.

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

Erstellen Sie ein AWS CodeBuild-Projekt

Richten Sie ein CodeBuild-Projekt ein, das angibt, wie Ihre Anwendung erstellt wird. Dazu gehört die Definition von Build-Umgebungen, Build-Befehlen und Abhängigkeiten.

• Erstellen Sie einen S3-Bucket zum Speichern der Build-Dateien.

• Suchen Sie nach AWS Code Build, erstellen Sie ein neues Projekt und stellen Sie CodeCommit als Quelle für Code und S3 für die Speicherung von Artefakten bereit

Um CodeBuild einzurichten, müssen Sie eine Build-Spezifikationsdatei mit dem Namen buildspec.yml in Ihrem Projektverzeichnis erstellen. Diese Datei enthält die Build-Befehle und Anweisungen für CodeBuild.

Ausführliche Anweisungen zum Erstellen einer buildspec.yml Datei finden Sie hier in der offiziellen Dokumentation.

 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

Schieben Sie die neue Datei von lokal in das Repository.

Danach können Sie das Projekt erstellen, um zu sehen, ob der Code aus dem Repo abgerufen wird und Artefakte erstellt werden.

Erstellen Sie eine CodePipeline

• Erstellen Sie eine neue Pipeline in AWS CodePipeline.

• Verbinden Sie die Pipeline mit Ihrem CodeCommit-Repository als Quelle.

• Konfigurieren Sie die Pipeline so, dass sie CodeBuild als Build-Phase verwendet.

• Fügen Sie eine Bereitstellungsphase hinzu, um CloudFormation mithilfe der von Ihnen erstellten Vorlage auszulösen.

Die Pipeline erstellt und stellt automatisch Code basierend auf dem Git-Commit bereit.

Testen Sie die Pipeline

• Öffnen Sie Ihr Projekt in IntelliJ.

• Nehmen Sie eine kleine Änderung in einer Ihrer Dateien vor, fügen Sie beispielsweise eine weitere Logger-Zeile hinzu.

• Übertragen Sie die Änderung in Ihr lokales Git-Repository.

• Schieben Sie den Commit in das CodeCommit-Repository.

 $ 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

• Gehen Sie zur AWS CodePipeline-Konsole.

• Die Pipeline sollte automatisch starten. Es ruft den neuesten Code aus dem Repository ab, erstellt das Projekt mit CodeBuild und stellt es mit CloudFormation bereit.

• Überwachen Sie den Fortschritt im CodePipeline-Dashboard.

Dadurch wird der Prozess simuliert, bei dem Sie Änderungen an Ihrem Code vornehmen, diese in das Repository übertragen und die CICD-Pipeline den aktualisierten Code automatisch auslösen und bereitstellen.

Durch die Nutzung von AWS API Gateway, Lambda, DynamoDB, CodeCommit, CodeBuild und CodePipeline zeigt der Artikel, wie man einen stabilen und automatisierten Bereitstellungsprozess gestaltet.

Vielen Dank fürs Lesen. Mögen Ihre Bemühungen ohne Server Erfolg und Innovation haben!