Wie man eine AWS Lambda-Funktion in Java 11 erstellt und überwacht

Serverless Computing ist eine moderne Cloud-basierte Anwendungsarchitektur, bei der die Infrastruktur der Anwendung und die Ebene der unterstützenden Dienste vollständig von der Softwareschicht abstrahiert sind. Während jede Anwendung weiterhin auf physische Server angewiesen ist, verlagern serverlose Anwendungen diese Verantwortung auf Cloud-Dienstleister wie Amazon Web Services (AWS).

In einem wirklich serverlosen Architekturparadigma läuft Ihr Lambda-Funktionscode auf einer Infrastruktur, die von einem Dritten gehostet und verwaltet wird, in der Regel einem Cloud-Dienst. Der Anbieter kümmert sich um alles, von der Bereitstellung, Skalierung und Lastverteilung bis hin zur Sicherung der Infrastruktur. Er verwaltet auch das AWS-Toolkit, die Betriebssysteme, die Patches, das serverlose Framework, die Code-Bibliotheken und alle notwendigen Support-Services. Sie zahlen nur für die Rechenzeit, die Ihre laufenden Anwendungen verbrauchen, während das serverlose Backend automatisch skaliert und die Last ausgleicht, wenn die Anwendungslast steigt oder sinkt – dies macht es kostengünstig und skalierbar.

Der globale Markt für serverlose Architekturen wurde im Jahr 2024 auf 25,3 Mrd. USD geschätzt und wird voraussichtlich von 2025 bis 2030 mit einer jährlichen Wachstumsrate von 14,1 % wachsen. Da immer mehr Entwickler und Unternehmen Serverless Computing einsetzen, müssen Sie wissen, wie Sie effiziente, ereignisgesteuerte Apps erstellen können, vor allem mit gängigen Sprachen wie Java.

Um Ihnen den Einstieg zu erleichtern, zeigen wir Ihnen, wie Sie eine Lambda-Funktion mit Java 11 erstellen, sie mit Amazon DynamoDB verbinden und mit der Telemetrie-API-Integration von Sumo Logic eine bessere AWS-Observability erhalten.

Was ist eine AWS Lambda-Funktion?

AWS Lambda ist ein serverloser, ereignisgesteuerter Rechenservice, mit dem Sie Code für jede Art von Anwendung oder Backend-Service ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Sie können Lambda-Funktionen aus über 200 AWS-Services und Software-as-a-Service (SaaS)-Anwendungen auslösen, darunter Amazon CloudWatch, Amazon S3, Amazon EC2 und mehr.

Diese Funktionen reagieren auf Ereignisse wie Daten, die von einem Amazon Simple Queue Service (SQS) zu einer Lambda-Funktion fließen oder auf eine Änderung in einer Datei in Amazon S3. Das Ereignis wird als erster Parameter an die Funktion übergeben. Lambda-Funktionen sind völlig zustandslos, das heißt, Sie haben keine Garantie, wo eine Funktion ausgeführt wird oder wie oft sie auf einer bestimmten Instanz ausgeführt wurde.

Wie man eine AWS Lambda-Funktion mit Java 11 programmiert

Mit AWS Lambda können Sie eine Lambda-Java-Funktion erstellen, die hochgeladen und für die Ausführung in der AWS Cloud konfiguriert werden kann. Obwohl diese Funktion in verschiedenen Sprachen geschrieben werden kann, werden wir uns auf die Erstellung einer AWS Lambda-Funktion mit Java 11 konzentrieren. Wir führen Sie durch die Schritte des Codierens, Konfigurierens und Testens Ihrer Funktion mithilfe der AWS-Konsole.

AWS Lambda-Beispiel: Ein einfacher Postleitzahlen-Validator

In diesem Beispiel erstellen wir eine einfache PLZ-Prüfung, die auf eine neue, einer Amazon DynamoDB-Tabelle hinzugefügten Adresse reagiert.

Schritt 0: Bevor Sie beginnen

• Stellen Sie sicher, dass Sie Zugriff auf die AWS Management Console haben. Das Erstellen und Bereitstellen dieses Beispiels sollte im Rahmen des kostenlosen AWS-Tiers nichts kosten.
• Deaktivieren Sie alle Trigger und löschen Sie die DynamoDB-Tabelle nach dem Test, um unnötige Nutzung zu vermeiden.

Schritt 1: Erstellen Sie eine DynamoDB-Tabelle

• Gehen Sie zur DynamoDB-Konsole.
• Erstellen Sie eine Tabelle namens US_Address_Table mit einem Primärschlüssel vom Typ id (String).
• Aktivieren Sie Streams mit NEW_IMAGE-Ansichtstyp.
• Kopieren Sie die ARN der Tabelle zur Verwendung im nächsten Schritt.

Schritt 2: Erstellen Sie eine Rolle für Ihre Lambda-Funktion

• Navigieren Sie zur IAM-Konsole.
• Erstellen Sie eine neue Rolle mit der verwalteten Policy AWSLambdaDynamoDBExecutionRole.
• Geben Sie der Rolle einen Namen, etwa lambda-validator.

Schritt 3: Fügen Sie Berechtigungen hinzu, um DynamoDB zu aktualisieren

• Fügen Sie eine Inline-Policy hinzu oder verwenden Sie die Konsole, um UpdateItem-Berechtigungen für Ihre DynamoDB-Tabelle unter Verwendung der ARN der Tabelle zu erteilen.

Schritt 4: Coden wir die Lambda-Funktion

• Verwenden Sie Java 11 und das AWS SDK v2. Hier ist eine vereinfachte Version der Lambda-Funktion:

package com.example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.*;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.regex.Pattern;
public class AddressValidator implements RequestHandler<DynamodbEvent, String> {
    private static final Pattern ZIP_CODE_PATTERN = Pattern.compile("^[0-9]{5}(?:-[0-9]{4})?$");
    private final ObjectMapper objectMapper = new ObjectMapper();
    private final DynamoDbClient dynamoDbClient = DynamoDbClient.builder().region(Region.US_WEST_2).build();
    private static final String TABLE_NAME = "US_Address_Table";
    public String handleRequest(DynamodbEvent event, Context context) {
        LambdaLogger logger = context.getLogger();
        for (DynamodbEvent.DynamodbStreamRecord record : event.getRecords()) {
            if ("INSERT".equals(record.getEventName())) {
                try {
                    String jsonAddress = record.getDynamodb().getNewImage().get("address").getS();
                    Address address = objectMapper.readValue(jsonAddress, Address.class);
                    if (!Boolean.TRUE.equals(address.getValidated())) {
                        address.setValidated(ZIP_CODE_PATTERN.matcher(address.getZipcode()).matches());
                        String updatedJson = objectMapper.writeValueAsString(address);
                        dynamoDbClient.updateItem(UpdateItemRequest.builder()
                                .tableName(TABLE_NAME)
                                .key(record.getDynamodb().getKeys())
                                .updateExpression("SET address = :a")
                                .expressionAttributeValues(Map.of(":a", AttributeValue.builder().s(updatedJson).build()))
                                .returnValues(ReturnValue.UPDATED_NEW)
                                .build());
                    }
                } catch (Exception e) {
                    logger.log("Exception during ZIP validation: " + e.getMessage());
                }
            }
        }
        return "Validated " + event.getRecords().size() + " records.";
    }
}  

Schritt 5: Laden Sie Ihre Lambda-Funktion über die AWS-Konsole hoch

• Verpacken Sie Ihre Java Lambda-Funktion als Fat-JAR mit Maven oder Gradle.
• Laden Sie sie über die AWS Lambda-Konsole hoch.
• Setzen Sie die Laufzeit auf Java 11 und den Handler auf com.example.AddressValidator::handleRequest.
• Weisen Sie die Rolle zu, die Sie zuvor erstellt haben.

Schritt 6: Testen Sie Ihre Funktion synchron in der AWS-Konsole

• Erstellen Sie ein Testereignis in der Lambda-Konsole.
• Verwenden Sie dieses JSON-Format:

{
  "Records": [
    {
      "eventID": "1",
      "eventVersion": "1.0",
      "dynamodb": {
        "Keys": {
          "id": {"S": "111-222-333"}
        },
        "NewImage": {
          "address": {
            "S": "{\"address1\":\"123 Main St\",\"city\":\"Portland\",\"state\":\"OR\",\"zipcode\":\"97229\"}"
          },
          "id": {"S": "111-222-333"}
        },
        "StreamViewType": "NEW_IMAGE",
        "SequenceNumber": "111-222-333",
        "SizeBytes": 26
      },
      "awsRegion": "us-west-2",
      "eventName": "INSERT",
      "eventSourceARN": "arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2023-01-01T00:00:00.000",
      "eventSource": "aws:dynamodb"
    }
  ]
}  

• Wenn Sie einen NullPointer oder einen Berechtigungsfehler erhalten, überprüfen Sie, ob die ARN der Tabelle korrekt ist und Ihre Lambda-Rolle über die erforderlichen Berechtigungen verfügt.
• Fügen Sie logger.log()-Anweisungen hinzu, um die Fehlersuche zu erleichtern.

Schritt 7: Lösen Sie die Lambda-Funktion von DynamoDB aus

• Gehen Sie in der DynamoDB-Konsole auf die Registerkarte „Triggers“ Ihrer Tabelle und verknüpfen Sie sie mit Ihrer Lambda-Funktion.
• Setzen Sie die Batchgröße für manuelles Testen auf 1.
• Sobald die Verbindung hergestellt ist, sollte das Einfügen eines neuen Elements in Ihre Tabelle den Lambda auslösen und das Adressobjekt mit einem validierten Feld aktualisieren.

Wie kann Sumo Logic Ihnen helfen?

Mit der SaaS Log Analytics Platform von Sumo Logic können Sie Logs, Plattformmetriken und Plattform-Traces von AWS Lambda über die Telemetrie-API direkt in Sumo Logic integrieren. Diese Integration verbessert die Observability in Ihrer gesamten Umgebung und ermöglicht Ihnen eine bessere Sichtbarkeit und eine einfache Überwachung Ihre Lambda-Funktion, ohne dass Sie die Infrastruktur verwalten müssen.

Sind Sie bereit, Ihre AWS-Überwachung und Observability auf die nächste Stufe zu heben? Melden Sie sich für unsere kostenlose 30-Tage-Testversion an.