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

Serverless Computing ist eine moderne Cloud-basierte Anwendungsarchitektur, bei der die Infrastruktur- und Support-Services-Schicht der Anwendung vollständig von der Software-Schicht abstrahiert ist. Während jede Anwendung immer noch auf physische Server angewiesen ist, verlagern serverlose Anwendungen diese Verantwortung auf Cloud Service Provider wie Amazon Web Services (AWS).

In einem wirklich serverlosen Architekturparadigma läuft Ihr Lambda-Funktionscode auf einer Infrastruktur, die von einem Drittanbieter, typischerweise einem Cloud-Service, gehostet und verwaltet wird. Der Anbieter kümmert sich um alles von der Bereitstellung und Skalierung bis zum Lastausgleich und zur Sicherung der Infrastruktur. Außerdem verwaltet es das AWS-Toolkit, Betriebssysteme, Patches, das Serverless-Framework, Code-Bibliotheken und alle notwendigen Support-Services. Sie zahlen nur für die Rechenzeit, die Ihre laufenden Anwendungen verbrauchen, während ein serverloses Backend automatisch skaliert und die Last ausgleicht, wenn die Anwendungslast steigt oder sinkt, wodurch es kosteneffizient und skalierbar ist.

Der globale Markt für serverlose Architekturen wurde im Jahr 2024 auf 25,3 Milliarden USD geschätzt und wird voraussichtlich von 2025 bis 2030 mit einer jährlichen Rate 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, insbesondere 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) an eine Lambda-Funktion oder eine Änderung in einer Datei innerhalb von Amazon S3 fließen. Das Ereignis wird als erster Parameter an die Funktion übergeben. Lambda-Funktionen sind völlig zustandslos, d. h. 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. Auch wenn diese Funktion in verschiedenen Sprachen geschrieben werden kann, werden wir uns auf die Erstellung einer AWS Lambda-Funktion mit Java 11 konzentrieren. Wir begleiten Sie durch die Schritte der Programmierung, Konfiguration und des Testens Ihrer Funktion mithilfe der AWS Console.

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 eine unnötige Nutzung zu vermeiden.

Schritt 1: Erstellen Sie eine DynamoDB-Tabelle

• Rufen Sie die DynamoDB-Konsole auf.
• 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: Lassen Sie uns die Lambda-Funktion coden

• 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 Console hoch

• Verpacken Sie Ihre Java Lambda-Funktion als Fat-JAR mit Maven oder Gradle.
• Laden Sie es ü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 das Lambda auslösen und das Adressobjekt mit einem validierten Feld aktualisieren.

Wie kann Sumo Logic Ihnen helfen?

Mit der SaaS Log-Analyse-Plattform 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 bietet Ihnen eine bessere Sichtbarkeit und einfache Überwachung Ihrer Lambda-Funktion, ohne zusätzlichen Aufwand für die Verwaltung der Infrastruktur.

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.