Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erste Schritte mit Lambda Managed Instances
<a name="lambda-managed-instances-getting-started"></a>

## Erstellen einer Lambda Managed Instance-Funktion (Konsole)
<a name="lambda-managed-instances-getting-started-console"></a>

Sie können die Lambda-Konsole verwenden, um eine Managed Instance-Funktion zu erstellen, die auf Amazon EC2-Instances ausgeführt wird, die von einem Kapazitätsanbieter verwaltet werden.

**Wichtig: ** Bevor Sie eine Managed Instance-Funktion erstellen, müssen Sie zunächst einen Kapazitätsanbieter erstellen. Für diese Funktionen muss ein Kapazitätsanbieter die Amazon EC2-Infrastruktur definieren, auf der Ihre Funktionen ausgeführt werden.

**Um eine Lambda Managed Instance-Funktion (Konsole) zu erstellen **

1. Öffnen Sie die Lambda-Konsole.

1. Wählen Sie im linken Navigationsbereich ** Capacity Providers ** aus.

1. Wählen Sie Kapazitätsanbieter ** erstellen aus**.

1. Geben Sie im ** Abschnitt Einstellungen für den ** Kapazitätsanbieter einen Namen für Ihren Kapazitätsanbieter ein.

1. Wählen Sie VPC und Berechtigungen für Ihren Kapazitätsanbieter aus. Sie können entweder eine vorhandene verwenden oder eine neue erstellen. Informationen zum Erstellen der erforderlichen Operatorrolle finden Sie unter [ Lambda-Operator-Rolle für Lambda Managed Instances. ](lambda-managed-instances-operator-role.md)

1. Erweiterten Sie **Advanced settings (Erweiterte Einstellungen)**.

1. Definieren Sie Ihre ** Instance-Anforderungen, ** indem Sie die Prozessorarchitektur und die Instanztypen auswählen.

1. Geben Sie unter ** Auto Scaling ** die maximale Anzahl von EC2-vCPUs für Ihren Kapazitätsanbieter an. Sie können auch den ** manuellen Instance-Skalierungsmodus wählen**, um Ihren eigenen Skalierungswert für eine präzise Steuerung festzulegen.

1. Wählen Sie ** Create Capacity Provider aus**, um einen neuen zu erstellen.

1. Wählen Sie **Create function**.

1. Wählen Sie **Verfassen von Grund auf** aus.

1. Geben Sie im ** Bereich ** Grundinformationen einen ** Funktionsnamen ein**.

1. Wählen Sie für ** Runtime ** eine der unterstützten Runtimes aus.

1. Wählen Sie die ** Architektur ** für Ihre Funktion (dieselbe wie die, die Sie für den Kapazitätsanbieter ausgewählt haben). Standardmäßig ** ** x86\_64.

1. Stellen Sie unter ** Berechtigungen sicher**, dass Sie über die Berechtigungen für die gewählte ** Ausführungsrolle verfügen. ** Andernfalls können Sie eine neue Rolle erstellen.

1. Wählen Sie unter ** Zusätzliche Konfigurationen ** den ** Compute-Typ ** als ** Lambda Managed Instances ** aus.

1. Der Kapazitätsanbieter-ARN des Kapazitätsanbieters, den Sie in den vorherigen Schritten erstellt haben, sollte vorab ausgewählt werden.

1. Wählen Sie die ** Speichergröße ** und das Verhältnis von Arbeitsspeicher für die ** Ausführungsumgebung (GiB) pro vCPU. **

1. Wählen Sie **Funktion erstellen**.

Ihre Lambda Managed Instance-Funktion wird erstellt und stellt Kapazität bei Ihrem angegebenen Kapazitätsanbieter bereit. Die Erstellung der Funktion dauert in der Regel mehrere Minuten. Sobald Sie fertig sind, können Sie Ihren Funktionscode bearbeiten und Ihren ersten Test ausführen.

## Erstellen einer Lambda Managed Instance-Funktion (AWS CLI)
<a name="lambda-managed-instances-getting-started-cli"></a>

### Voraussetzungen
<a name="lambda-managed-instances-prerequisites"></a>

Stellen Sie vor dem Beginn sicher, dass Sie über das Folgende verfügen:
+ **AWS CLI ** — Installieren und konfigurieren Sie die AWS CLI. Weitere Informationen finden Sie unter [ Installation oder Aktualisierung der neuesten Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ **IAM-Berechtigungen ** — Ihr IAM-Benutzer oder Ihre IAM-Rolle muss über Berechtigungen verfügen, um Lambda-Funktionen und Kapazitätsanbieter zu erstellen und IAM-Rollen zu übergeben. Beachten Sie, dass Sie diese Informationen auch benötigen, `iam:CreateServiceLinkedRole` wenn Sie zum ersten Mal einen Kapazitätsanbieter im Konto erstellen oder wenn die Service Linked Role (SLR) gelöscht wurde.

### Schritt 1: Erstellen Sie die erforderlichen IAM-Rollen
<a name="lambda-managed-instances-step1-iam"></a>

Für Lambda Managed Instances sind zwei IAM-Rollen erforderlich: eine Ausführungsrolle für Ihre Funktion und eine Betreiberrolle für den Kapazitätsanbieter. Die Betreiberrolle ermöglicht es Lambda, Amazon EC2-Instances in Ihrem Namen zu starten, zu beenden und zu überwachen. Die Rolle zur Funktionsausführung gewährt der Funktion Berechtigungen für den Zugriff auf andere AWS Dienste und Ressourcen.

**Um die Lambda-Ausführungsrolle zu erstellen **

1. Erstellen Sie ein Dokument mit einer Vertrauensrichtlinie, das es Lambda ermöglicht, die Rolle zu übernehmen:

   ```
   cat > lambda-trust-policy.json << 'EOF'
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "lambda.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   EOF
   ```

1. Erstellen Sie die Ausführungsrolle:

   ```
   aws iam create-role \
     --role-name MyLambdaExecutionRole \
     --assume-role-policy-document file://lambda-trust-policy.json
   ```

1. Hängen Sie die grundlegende Ausführungsrichtlinie an:

   ```
   aws iam attach-role-policy \
     --role-name MyLambdaExecutionRole \
     --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
   ```

**So erstellen Sie die Rolle „Betreiber“ des Kapazitätsanbieters **

1. Erstellen Sie ein Dokument mit einer Vertrauensrichtlinie, das es Lambda ermöglicht, die Betreiberrolle zu übernehmen:

   ```
   cat > operator-trust-policy.json << 'EOF'
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "lambda.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   EOF
   ```

1. Erstellen Sie die Operatorrolle:

   ```
   aws iam create-role \
     --role-name MyCapacityProviderOperatorRole \
     --assume-role-policy-document file://operator-trust-policy.json
   ```

1. Hängen Sie die erforderliche EC2-Berechtigungsrichtlinie an:

   ```
   aws iam attach-role-policy \
     --role-name MyCapacityProviderOperatorRole \
     --policy-arn arn:aws:iam::aws:policy/AWSLambdaManagedEC2ResourceOperator
   ```

### Schritt 2: VPC-Ressourcen einrichten
<a name="lambda-managed-instances-step2-vpc"></a>

Lambda Managed Instances werden in Ihrer VPC ausgeführt und benötigen ein Subnetz und eine Sicherheitsgruppe.

**Um VPC-Ressourcen zu erstellen **

1. Erstellen Sie eine VPC:

   ```
   VPC_ID=$(aws ec2 create-vpc \
     --cidr-block 10.0.0.0/16 \
     --query 'Vpc.VpcId' \
     --output text)
   ```

1. Erstellen Sie ein Subnetz:

   ```
   SUBNET_ID=$(aws ec2 create-subnet \
     --vpc-id $VPC_ID \
     --cidr-block 10.0.1.0/24 \
     --query 'Subnet.SubnetId' \
     --output text)
   ```

1. Erstellen Sie eine Sicherheitsgruppe:

   ```
   SECURITY_GROUP_ID=$(aws ec2 create-security-group \
     --group-name my-capacity-provider-sg \
     --description "Security group for Lambda Managed Instances" \
     --vpc-id $VPC_ID \
     --query 'GroupId' \
     --output text)
   ```

**Hinweis: Für ** Ihre Lambda Managed Instances-Funktionen ist eine VPC-Konfiguration erforderlich, um auf Ressourcen außerhalb der VPC zuzugreifen und Telemetriedaten an Logs und zu übertragen. CloudWatch X-Ray Einzelheiten zur Konfiguration finden Sie unter [ Networking for Lambda Managed Instances. ](lambda-managed-instances-networking.md)

### Schritt 3: Erstellen eines Kapazitätsanbieters
<a name="lambda-managed-instances-step3-capacity-provider"></a>

Ein Kapazitätsanbieter verwaltet die EC2-Instances, auf denen Ihre Lambda-Funktionen ausgeführt werden.

**Um einen Kapazitätsanbieter zu erstellen **

```
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)

aws lambda create-capacity-provider \
  --capacity-provider-name my-capacity-provider \
  --vpc-config SubnetIds=[$SUBNET_ID],SecurityGroupIds=[$SECURITY_GROUP_ID] \
  --permissions-config CapacityProviderOperatorRoleArn=arn:aws:iam::${ACCOUNT_ID}:role/MyCapacityProviderOperatorRole \
  --instance-requirements Architectures=[x86_64] \
  --capacity-provider-scaling-config MaxVCpuCount=30
```

Mit diesem Befehl wird ein Kapazitätsanbieter mit der folgenden Konfiguration erstellt:
+ **VPC-Konfiguration ** — Gibt das Subnetz und die Sicherheitsgruppe für die EC2-Instances an
+ **Berechtigungen ** — Definiert die IAM-Rolle, die Lambda zur Verwaltung von EC2-Instances verwendet
+ **Instance-Anforderungen ** — Spezifiziert die x86\_64-Architektur
+ **Skalierungskonfiguration ** — Legt ein Maximum von 30 vCPUs für den Kapazitätsanbieter fest

### Schritt 4: Erstellen Sie eine Lambda-Funktion mit Inline-Code
<a name="lambda-managed-instances-step4-function"></a>

**Um eine Funktion mit Inline-Code zu erstellen **

1. Erstellen Sie zunächst eine einfache Python-Funktion und packen Sie sie inline ein:

   ```
   # Create a temporary directory for the function code
   mkdir -p /tmp/my-lambda-function
   cd /tmp/my-lambda-function
   
   # Create a simple Python handler
   cat > lambda_function.py << 'EOF'
   import json
   
   def lambda_handler(event, context):
       return {
           'statusCode': 200,
           'body': json.dumps({
               'message': 'Hello from Lambda Managed Instances!',
               'event': event
           })
       }
   EOF
   
   # Create a ZIP file
   zip function.zip lambda_function.py
   ```

1. Erstellen Sie die Lambda-Funktion mithilfe der Inline-ZIP-Datei:

   ```
   ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   REGION=$(aws configure get region)
   
   aws lambda create-function \
     --function-name my-managed-instance-function \
     --package-type Zip \
     --runtime python3.13 \
     --handler lambda_function.lambda_handler \
     --zip-file fileb:///tmp/my-lambda-function/function.zip \
     --role arn:aws:iam::${ACCOUNT_ID}:role/MyLambdaExecutionRole \
     --architectures x86_64 \
     --memory-size 2048 \
     --ephemeral-storage Size=512 \
     --capacity-provider-config LambdaManagedInstancesCapacityProviderConfig={CapacityProviderArn=arn:aws:lambda:${REGION}:${ACCOUNT_ID}:capacity-provider:my-capacity-provider}
   ```

   Die Funktion wird erstellt mit:
   + **Laufzeit ** — Python 3.13
   + **Handler ** — Die `lambda_handler` Funktion in `lambda_function.py`
   + **Speicher ** — 2048 MB
   + **Kurzlebiger Speicher — 512 MB **
   + **Kapazitätsanbieter ** — Links zu dem von Ihnen erstellten Kapazitätsanbieter

### Schritt 5: Veröffentlichen Sie eine Funktionsversion
<a name="lambda-managed-instances-step5-publish"></a>

Um Ihre Funktion auf Lambda Managed Instances auszuführen, müssen Sie eine Version veröffentlichen.

**Um eine Funktionsversion zu veröffentlichen **

```
aws lambda publish-version \
  --function-name my-managed-instance-function
```

Mit diesem Befehl wird Version 1 Ihrer Funktion veröffentlicht und für den Kapazitätsanbieter bereitgestellt.

### Schritt 6: Rufen Sie Ihre Funktion auf
<a name="lambda-managed-instances-step6-invoke"></a>

Nach der Veröffentlichung können Sie Ihre Funktion aufrufen.

**Um Ihre Funktion aufzurufen **

```
aws lambda invoke \
  --function-name my-managed-instance-function:1 \
  --payload '{"name": "World"}' \
  response.json

# View the response
cat response.json
```

Die Funktion wird auf den EC2-Instances ausgeführt, die von Ihrem Kapazitätsanbieter verwaltet werden, und gibt eine Antwort zurück.

### Bereinigen
<a name="lambda-managed-instances-cleanup"></a>

Löschen Sie die Ressourcen, die Sie erstellt haben, um zu vermeiden, dass Gebühren anfallen:

1. Löschen Sie die Funktion:

   ```
   aws lambda delete-function --function-name my-managed-instance-function
   ```

1. Löschen Sie den Kapazitätsanbieter:

   ```
   aws lambda delete-capacity-provider --capacity-provider-name my-capacity-provider
   ```

1. Löschen Sie die VPC-Ressourcen:

   ```
   aws ec2 delete-security-group --group-id $SECURITY_GROUP_ID
   aws ec2 delete-subnet --subnet-id $SUBNET_ID
   aws ec2 delete-vpc --vpc-id $VPC_ID
   ```

1. Löschen Sie die IAM-Rollen:

   ```
   aws iam detach-role-policy \
     --role-name MyLambdaExecutionRole \
     --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
   aws iam detach-role-policy \
     --role-name MyCapacityProviderOperatorRole \
     --policy-arn arn:aws:iam::aws:policy/AWSLambdaManagedEC2ResourceOperator
   
   aws iam delete-role --role-name MyLambdaExecutionRole
   aws iam delete-role --role-name MyCapacityProviderOperatorRole
   ```