AWS Lambda API Nutzung für Serverless im Jahr 2026

Kurz gesagt

Die AWS Lambda API ermöglicht es Entwicklern, serverlose Funktionen programmatisch bereitzustellen, zu verwalten und aufzurufen. Sie verwendet IAM-Authentifizierung, RESTful-Endpunkte für die Funktionsverwaltung, asynchrone und synchrone Aufrufoptionen mit Kontolimits für die Parallelität. Dieser Leitfaden behandelt die Einrichtung der Authentifizierung, die Bereitstellung von Funktionen, Aufrufmuster, das Event-Source-Mapping und Strategien für die serverlose Architektur in der Produktion.

Einleitung

AWS Lambda verarbeitet monatlich Billionen von Anfragen für über 1 Million aktive Benutzer. Für Entwickler, die serverlose Anwendungen, Automatisierungstools oder ereignisgesteuerte Architekturen erstellen, ist die Lambda API-Integration nicht optional – sie ist essenziell für Infrastructure as Code und CI/CD-Pipelines.

Hier ist die Realität: Teams, die mehr als 50 Lambda-Funktionen manuell verwalten, verlieren wöchentlich 10-15 Stunden für Bereitstellungen, Konfigurationsaktualisierungen und Überwachung. Eine solide Lambda API-Integration automatisiert Bereitstellungen, implementiert Blue-Green-Releases und ermöglicht dynamische Skalierung basierend auf der Nachfrage.

Dieser Leitfaden führt Sie durch den vollständigen Integrationsprozess der AWS Lambda API. Sie lernen die IAM-Authentifizierung, die Erstellung und Bereitstellung von Funktionen, Aufrufmuster (synchron/asynchron), das Event-Source-Mapping, geschichtete Architekturen und Produktionsbereitstellungsstrategien kennen. Am Ende verfügen Sie über eine produktionsreife Lambda-Integration.

Was ist die AWS Lambda API?

AWS Lambda bietet eine RESTful API zur Verwaltung serverloser Compute-Funktionen. Die API verwaltet:

• Erstellung, Aktualisierung und Löschung von Funktionen
• Code-Bereitstellung und -Versionierung
• Funktionsaufruf (synchron und asynchron)
• Event-Source-Mapping (SQS, Kinesis, DynamoDB, S3)
• Ebenenverwaltung für gemeinsamen Code
• Alias- und Routing-Konfiguration
• Parallelitäts- und Reservierungskapazitätsverwaltung
• Protokollierungs- und Überwachungsintegration

Hauptmerkmale

Lambda Laufzeitunterstützung

API-Architekturübersicht

Lambda verwendet die AWS-Dienst-API-Struktur:

https://lambda.{region}.amazonaws.com/2015-03-31/

API-Versionen

Erste Schritte: Authentifizierungseinrichtung

Schritt 1: AWS-Konto und IAM-Benutzer erstellen

Vor dem Zugriff auf die API:

1. Besuchen Sie die AWS-Konsole
2. AWS-Konto erstellen
3. Gehen Sie zu IAM-Konsole > Benutzer > Benutzer erstellen
4. Lambda-Ausführungsrichtlinien anfügen

Schritt 2: IAM-Anmeldeinformationen generieren

Erstellen Sie Zugriffsschlüssel für den programmatischen Zugriff:

# AWS CLI-Methode
aws iam create-access-key --user-name lambda-deployer

# Ausgabe: Bewahren Sie diese sicher auf
{
  "AccessKey": {
    "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
    "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
  }
}

Sicherheitshinweis: Speichern Sie Anmeldeinformationen sicher:

# ~/.aws/credentials
[lambda-deployer]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

# Oder verwenden Sie Umgebungsvariablen
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
export AWS_DEFAULT_REGION="us-east-1"

Schritt 3: AWS Signature Version 4 verstehen

Alle Lambda API-Anfragen erfordern eine SigV4-Signatur:

const crypto = require('crypto');

class AWSSigner {
  constructor(accessKeyId, secretAccessKey, region, service = 'lambda') {
    this.accessKeyId = accessKeyId;
    this.secretAccessKey = secretAccessKey;
    this.region = region;
    this.service = service;
  }

  sign(request, body = null) {
    const now = new Date();
    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, '');
    const dateStamp = amzDate.slice(0, 8);

    // Task 1: Create canonical request
    const hashedPayload = body ? crypto.createHash('sha256').update(body).digest('hex') : 'UNSIGNED-PAYLOAD';
    const canonicalUri = request.path;
    const canonicalQuerystring = request.query || '';
    const canonicalHeaders = `host:${request.host}\nx-amz-date:${amzDate}\n`;
    const signedHeaders = 'host;x-amz-date';
    const canonicalRequest = `${request.method}\n${canonicalUri}\n${canonicalQuerystring}\n${canonicalHeaders}\n${signedHeaders}\n${hashedPayload}`;

    // Task 2: Create string to sign
    const algorithm = 'AWS4-HMAC-SHA256';
    const credentialScope = `${dateStamp}/${this.region}/${this.service}/aws4_request`;
    const hash = crypto.createHash('sha256').update(canonicalRequest).digest('hex');
    const stringToSign = `${algorithm}\n${amzDate}\n${credentialScope}\n${hash}`;

    // Task 3: Calculate signature
    const kDate = this.hmac(`AWS4${this.secretAccessKey}`, dateStamp);
    const kRegion = this.hmac(kDate, this.region);
    const kService = this.hmac(kRegion, this.service);
    const kSigning = this.hmac(kService, 'aws4_request');
    const signature = this.hmac(kSigning, stringToSign, 'hex');

    // Task 4: Add authorization header
    const authorizationHeader = `${algorithm} Credential=${this.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;

    return {
      'Authorization': authorizationHeader,
      'X-Amz-Date': amzDate,
      'X-Amz-Content-Sha256': hashedPayload
    };
  }

  hmac(key, string, encoding = 'buffer') {
    return crypto.createHmac('sha256', key).update(string).digest(encoding);
  }
}

// Verwendung
const signer = new AWSSigner(
  process.env.AWS_ACCESS_KEY_ID,
  process.env.AWS_SECRET_ACCESS_KEY,
  'us-east-1'
);

Schritt 4: Lambda API-Client erstellen

const LAMBDA_BASE_URL = 'https://lambda.us-east-1.amazonaws.com/2015-03-31';

const lambdaRequest = async (path, options = {}) => {
  const url = new URL(`${LAMBDA_BASE_URL}${path}`);
  const method = options.method || 'GET';
  const body = options.body ? JSON.stringify(options.body) : null;

  const signer = new AWSSigner(
    process.env.AWS_ACCESS_KEY_ID,
    process.env.AWS_SECRET_ACCESS_KEY,
    'us-east-1'
  );

  const headers = signer.sign({ method, host: 'lambda.us-east-1.amazonaws.com', path }, body);

  const response = await fetch(url.toString(), {
    method,
    headers: {
      'Content-Type': 'application/json',
      ...headers,
      ...options.headers
    },
    body
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Lambda API Error: ${error.Message}`);
  }

  return response.json();
};

// Verwendung
const functions = await lambdaRequest('/functions');
console.log(`Gefunden ${functions.Functions.length} Funktionen`);

Alternative: AWS SDK verwenden

Für den Produktionseinsatz übernimmt das AWS SDK die Signierung automatisch:

const { LambdaClient, ListFunctionsCommand, CreateFunctionCommand, InvokeCommand } = require('@aws-sdk/client-lambda');

const lambda = new LambdaClient({ region: 'us-east-1' });

// Funktionen auflisten
const listCommand = new ListFunctionsCommand({});
const result = await lambda.send(listCommand);

// Funktion erstellen
const createCommand = new CreateFunctionCommand({
  FunctionName: 'my-function',
  Runtime: 'nodejs20.x',
  Role: 'arn:aws:iam::123456789012:role/lambda-execution-role',
  Handler: 'index.handler',
  Code: {
    S3Bucket: 'my-bucket',
    S3Key: 'function.zip'
  }
});

const fn = await lambda.send(createCommand);

Funktionsverwaltung

Eine Funktion erstellen

Lambda-Funktion über API erstellen:

const createFunction = async (functionConfig) => {
  const response = await lambdaRequest('/functions', {
    method: 'POST',
    body: {
      FunctionName: functionConfig.name,
      Runtime: functionConfig.runtime || 'nodejs20.x',
      Role: functionConfig.roleArn,
      Handler: functionConfig.handler || 'index.handler',
      Code: {
        S3Bucket: functionConfig.s3Bucket,
        S3Key: functionConfig.s3Key
      },
      Description: functionConfig.description || '',
      Timeout: functionConfig.timeout || 3,
      MemorySize: functionConfig.memorySize || 128,
      Environment: {
        Variables: functionConfig.environment || {}
      },
      Tags: functionConfig.tags || {}
    }
  });

  return response;
};

// Verwendung
const fn = await createFunction({
  name: 'order-processor',
  roleArn: 'arn:aws:iam::123456789012:role/lambda-execution-role',
  handler: 'index.handler',
  runtime: 'nodejs20.x',
  s3Bucket: 'my-deployments-bucket',
  s3Key: 'order-processor/v1.0.0.zip',
  description: 'Bestellungen aus der SQS-Warteschlange verarbeiten',
  timeout: 30,
  memorySize: 512,
  environment: {
    DB_HOST: 'db.example.com',
    LOG_LEVEL: 'info'
  }
});

console.log(`Funktion erstellt: ${fn.FunctionArn}`);

Code direkt hochladen

Für kleine Funktionen (<50 MB gezippt):

const fs = require('fs');
const path = require('path');

const createFunctionWithZip = async (functionName, zipPath) => {
  const zipBuffer = fs.readFileSync(zipPath);
  const base64Code = zipBuffer.toString('base64');

  const response = await lambdaRequest('/functions', {
    method: 'POST',
    body: {
      FunctionName: functionName,
      Runtime: 'nodejs20.x',
      Role: 'arn:aws:iam::123456789012:role/lambda-execution-role',
      Handler: 'index.handler',
      Code: {
        ZipFile: base64Code
      }
    }
  });

  return response;
};

// Funktion packen
// zip -r function.zip index.js node_modules/
await createFunctionWithZip('my-function', './function.zip');

Funktionscode aktualisieren

Neue Code-Version bereitstellen:

const updateFunctionCode = async (functionName, updateConfig) => {
  const response = await lambdaRequest(`/functions/${functionName}/code`, {
    method: 'PUT',
    body: {
      S3Bucket: updateConfig.s3Bucket,
      S3Key: updateConfig.s3Key,
      Publish: updateConfig.publish || false
    }
  });

  return response;
};

// Verwendung
const updated = await updateFunctionCode('order-processor', {
  s3Bucket: 'my-deployments-bucket',
  s3Key: 'order-processor/v1.1.0.zip',
  publish: true // Neue Version erstellen
});

console.log(`Aktualisiert auf Version: ${updated.Version}`);

Funktionskonfiguration aktualisieren

Timeout, Speicher, Umgebung ändern:

const updateFunctionConfig = async (functionName, config) => {
  const response = await lambdaRequest(`/functions/${functionName}/configuration`, {
    method: 'PUT',
    body: {
      Runtime: config.runtime,
      Handler: config.handler,
      Description: config.description,
      Timeout: config.timeout,
      MemorySize: config.memorySize,
      Environment: {
        Variables: config.environment
      }
    }
  });

  return response;
};

// Verwendung
const updated = await updateFunctionConfig('order-processor', {
  timeout: 60,
  memorySize: 1024,
  environment: {
    DB_HOST: 'new-db.example.com',
    LOG_LEVEL: 'debug'
  }
});

Eine Funktion löschen

Funktion entfernen:

const deleteFunction = async (functionName, qualifier = null) => {
  const path = qualifier
    ? `/functions/${functionName}?Qualifier=${qualifier}`
    : `/functions/${functionName}`;

  await lambdaRequest(path, { method: 'DELETE' });
  console.log(`Funktion ${functionName} gelöscht`);
};

Funktionsaufruf

Synchroner Aufruf (Anfrage-Antwort)

Funktion aufrufen und auf Antwort warten:

const invokeFunction = async (functionName, payload, qualifier = null) => {
  const path = qualifier
    ? `/functions/${functionName}/invocations?Qualifier=${qualifier}`
    : `/functions/${functionName}/invocations`;

  const response = await lambdaRequest(path, {
    method: 'POST',
    headers: {
      'X-Amz-Invocation-Type': 'RequestResponse', // Synchron
      'X-Amz-Log-Type': 'Tail' // Protokolle einschließen
    },
    body: payload
  });

  // Antwort parsen
  const result = JSON.parse(Buffer.from(response.Payload).toString());
  const logs = Buffer.from(response.LogResult, 'base64').toString();

  return { result, logs };
};

// Verwendung
const { result, logs } = await invokeFunction('order-processor', {
  orderId: 'ORD-12345',
  customerId: 'CUST-67890',
  items: [
    { sku: 'PROD-001', quantity: 2 },
    { sku: 'PROD-002', quantity: 1 }
  ]
});

console.log(`Ergebnis: ${JSON.stringify(result)}`);
console.log(`Protokolle:\n${logs}`);

Asynchroner Aufruf (Fire-and-Forget)

Funktion aufrufen ohne zu warten:

const invokeAsync = async (functionName, payload) => {
  const response = await lambdaRequest(`/functions/${functionName}/invocations`, {
    method: 'POST',
    headers: {
      'X-Amz-Invocation-Type': 'Event', // Asynchron
      'X-Amz-Log-Type': 'None'
    },
    body: payload
  });

  return {
    statusCode: response.StatusCode,
    executionId: response['X-Amz-Execution-Id']
  };
};

// Verwendung - asynchrone Verarbeitung auslösen
const result = await invokeAsync('email-sender', {
  to: 'customer@example.com',
  template: 'order-confirmation',
  data: { orderId: 'ORD-12345' }
});

console.log(`Asynchrone Aufruf-ID: ${result.executionId}`);

Probelauf-Aufruf

Berechtigungen testen ohne Ausführung:

const dryRunInvocation = async (functionName) => {
  const response = await lambdaRequest(`/functions/${functionName}/invocations`, {
    method: 'POST',
    headers: {
      'X-Amz-Invocation-Type': 'DryRun'
    }
  });

  return response;
};

// Verwendung - IAM-Berechtigungen überprüfen
try {
  await dryRunInvocation('order-processor');
  console.log('Aufrufberechtigungen OK');
} catch (error) {
  console.error('Berechtigung verweigert:', error.message);
}

Aufruf-Antworttypen

Versions- und Aliasverwaltung

Versionen veröffentlichen

Unveränderliche Funktionsversion erstellen:

const publishVersion = async (functionName, description = null) => {
  const response = await lambdaRequest(`/functions/${functionName}/versions`, {
    method: 'POST',
    body: description ? { Description: description } : {}
  });

  return response;
};

// Verwendung
const version = await publishVersion('order-processor', 'v1.2.0 - Steuerberechnung hinzugefügt');
console.log(`Veröffentlichte Version: ${version.Version}`);

Aliase erstellen

Benannten Zeiger auf Version erstellen:

const createAlias = async (functionName, aliasName, version, description = null) => {
  const response = await lambdaRequest(`/functions/${functionName}/aliases`, {
    method: 'POST',
    body: {
      Name: aliasName,
      FunctionVersion: version,
      Description: description
    }
  });

  return response;
};

// Verwendung - Produktions-Alias erstellen
const prodAlias = await createAlias('order-processor', 'prod', '5', 'Produktionsversion');
console.log(`Alias ARN: ${prodAlias.AliasArn}`);

Traffic-Verschiebung mit Routing-Konfiguration

Traffic schrittweise auf neue Version verschieben:

const updateAliasWithRouting = async (functionName, aliasName, routingConfig) => {
  const response = await lambdaRequest(`/functions/${functionName}/aliases/${aliasName}`, {
    method: 'PUT',
    body: {
      RoutingConfig: {
        AdditionalVersionWeights: routingConfig
      }
    }
  });

  return response;
};

// Verwendung - 10% Traffic zu Version 6, 90% zu Version 5
await updateAliasWithRouting('order-processor', 'prod', {
  '6': 0.1
});

// Nach Validierung auf 100% verschieben
await updateAliasWithRouting('order-processor', 'prod', {});

Alias-Anwendungsfälle

Ereignisquellen-Mapping

SQS-Trigger erstellen

SQS-Warteschlange mit Lambda verbinden:

const createSQSEventSource = async (functionName, queueArn, batchSize = 10) => {
  const response = await lambdaRequest('/event-source-mappings', {
    method: 'POST',
    body: {
      EventSourceArn: queueArn,
      FunctionName: functionName,
      BatchSize: batchSize,
      Enabled: true
    }
  });

  return response;
};

// Verwendung
const mapping = await createSQSEventSource(
  'order-processor',
  'arn:aws:sqs:us-east-1:123456789012:orders-queue',
  10
);

console.log(`Ereignisquelle erstellt: ${mapping.UUID}`);

DynamoDB-Stream-Trigger erstellen

DynamoDB-Stream mit Lambda verbinden:

const createDynamoDBEventSource = async (functionName, streamArn, startingPosition = 'LATEST') => {
  const response = await lambdaRequest('/event-source-mappings', {
    method: 'POST',
    body: {
      EventSourceArn: streamArn,
      FunctionName: functionName,
      StartingPosition: startingPosition,
      BatchSize: 100,
      BisectBatchOnFunctionError: true,
      MaximumRetryAttempts: 3
    }
  });

  return response;
};

// Verwendung
await createDynamoDBEventSource(
  'user-analytics',
  'arn:aws:dynamodb:us-east-1:123456789012:table/Users/stream/2026-03-25T00:00:00.000'
);

Ereignisquellentypen

Ebenenverwaltung

Eine Ebene erstellen

Gemeinsamen Code/Abhängigkeiten packen:

const createLayer = async (layerName, layerConfig) => {
  const response = await lambdaRequest('/layers', {
    method: 'POST',
    body: {
      LayerName: layerName,
      Description: layerConfig.description,
      CompatibleRuntimes: layerConfig.runtimes,
      Content: {
        S3Bucket: layerConfig.s3Bucket,
        S3Key: layerConfig.s3Key
      }
    }
  });

  return response;
};

// Verwendung
const layer = await createLayer('shared-utils', {
  description: 'Gemeinsame Utilities und Abhängigkeiten',
  runtimes: ['nodejs20.x', 'nodejs18.x'],
  s3Bucket: 'my-layers-bucket',
  s3Key: 'shared-utils/v1.zip'
});

console.log(`Ebenen-ARN: ${layer.LayerArn}`);

Ebenen in Funktionen verwenden

Ebenen an Funktion anfügen:

const createFunctionWithLayers = async (functionConfig) => {
  const response = await lambdaRequest('/functions', {
    method: 'POST',
    body: {
      FunctionName: functionConfig.name,
      Runtime: functionConfig.runtime,
      Role: functionConfig.roleArn,
      Handler: functionConfig.handler,
      Code: {
        S3Bucket: functionConfig.s3Bucket,
        S3Key: functionConfig.s3Key
      },
      Layers: functionConfig.layers // Array von Ebenen-ARNs
    }
  });

  return response;
};

// Verwendung
await createFunctionWithLayers({
  name: 'api-handler',
  roleArn: 'arn:aws:iam::123456789012:role/lambda-execution-role',
  handler: 'index.handler',
  runtime: 'nodejs20.x',
  s3Bucket: 'my-deployments-bucket',
  s3Key: 'api-handler/v1.0.0.zip',
  layers: [
    'arn:aws:lambda:us-east-1:123456789012:layer:shared-utils:1',
    'arn:aws:lambda:us-east-1:123456789012:layer:aws-sdk:3'
  ]
});

Parallelität und Skalierung

Reservierte Parallelität festlegen

Kapazität für kritische Funktionen reservieren:

const putFunctionConcurrency = async (functionName, reservedConcurrentExecutions) => {
  const response = await lambdaRequest(`/functions/${functionName}/concurrency`, {
    method: 'PUT',
    body: {
      ReservedConcurrentExecutions: reservedConcurrentExecutions
    }
  });

  return response;
};

// Verwendung - 100 gleichzeitige Ausführungen reservieren
await putFunctionConcurrency('order-processor', 100);

Konto-Parallelitätslimits

Checkliste für die Produktionsbereitstellung

Vor der Bereitstellung in der Produktion:

• [ ] AWS SDK für automatische SigV4-Signierung verwenden
• [ ] Versionierung mit Aliasen implementieren
• [ ] Reservierte Parallelität für kritische Funktionen konfigurieren
• [ ] Dead Letter Queues (DLQ) für asynchrone Aufrufe einrichten
• [ ] X-Ray-Tracing für Debugging aktivieren
• [ ] VPC für Datenbankzugriff konfigurieren
• [ ] Strukturierte Protokollierung (JSON-Format) implementieren
• [ ] CloudWatch-Alarme einrichten
• [ ] Ebenen für gemeinsame Abhängigkeiten verwenden
• [ ] Blue-Green-Bereitstellungsstrategie implementieren

Anwendungsfälle aus der Praxis

API-Backend

Ein SaaS-Unternehmen erstellt eine serverlose REST-API:

• Herausforderung: Variabler Traffic, unvorhersehbare Skalierung
• Lösung: Lambda + API Gateway mit Autoscaling
• Ergebnis: 99,99 % Verfügbarkeit, 60 % Kostenreduzierung gegenüber EC2

Hauptimplementierung:

• Lambda-Funktionen pro Ressource
• API Gateway für Routing/Authentifizierung
• DynamoDB für Datenspeicherung
• Bereitgestellte Parallelität für konsistente Latenz

Ereignisverarbeitungs-Pipeline

Eine E-Commerce-Plattform verarbeitet Bestellungen:

• Herausforderung: Bestellspitzen während Verkaufsaktionen
• Lösung: SQS + Lambda mit Batch-Verarbeitung
• Ergebnis: Keine verlorenen Bestellungen, 10-fache Spitzenlastbewältigung

Hauptimplementierung:

• SQS-Warteschlange puffert Bestellungen
• Lambda verarbeitet 10 Nachrichten/Batch
• DLQ für fehlgeschlagene Nachrichten
• CloudWatch-Benachrichtigungen bei Warteschlangentiefe

Fazit

Die AWS Lambda API bietet umfassende serverlose Compute-Funktionen. Die wichtigsten Erkenntnisse:

• IAM-Authentifizierung mit SigV4-Signatur (AWS SDK verwenden)
• Synchrone und asynchrone Aufrufmuster
• Versions- und Aliasverwaltung für Bereitstellungen
• Ereignisquellen-Mapping für serverlose Architekturen
• Ebenen für gemeinsamen Code und Abhängigkeiten
• Apidog optimiert API-Tests und Teamzusammenarbeit

FAQ-Bereich

Wie authentifiziere ich mich bei der Lambda API?

Verwenden Sie AWS IAM-Anmeldeinformationen mit Signature Version 4-Signierung. Das AWS SDK übernimmt die Signierung automatisch.

Was ist der Unterschied zwischen synchronem und asynchronem Aufruf?

Synchron (RequestResponse) wartet auf den Abschluss der Funktion und gibt Ergebnisse zurück. Asynchron (Event) reiht die Anfrage ein und kehrt sofort zurück.

Wie funktionieren Lambda-Versionen?

Jede veröffentlichte Version ist ein unveränderlicher Schnappschuss Ihrer Funktion. Verwenden Sie Aliase, um auf bestimmte Versionen zu verweisen und die Traffic-Verschiebung zu ermöglichen.

Was sind Lambda-Ebenen?

Ebenen packen Code und Abhängigkeiten separat vom Funktionscode, was die gemeinsame Nutzung von Bibliotheken über mehrere Funktionen hinweg ermöglicht.

Wie reduziere ich Kaltstarts?

Verwenden Sie bereitgestellte Parallelität, kleinere Bereitstellungspakete und kompilierte Sprachen (Go, Rust) für latenzkritische Funktionen.

Was ist reservierte Parallelität?

Reservierte Parallelität garantiert Ausführungs-Slots für bestimmte Funktionen und verhindert so Probleme mit "lauten Nachbarn".

Kann ich Lambda von S3 aus auslösen?

Ja, konfigurieren Sie S3-Ereignisbenachrichtigungen, um Lambda bei der Erstellung/Löschung von Objekten aufzurufen.