Bereitstellen von Go-Lambda-Funktionen mit Container-Images

Fokusmodus

Bereitstellen von Go-Lambda-Funktionen mit Container-Images - AWS Lambda

AWS Basis-Images für die Bereitstellung von Go-Funktionen Laufzeitschnittstellen-Clients von Go Verwenden eines AWS reinen Betriebssystem-Basisimages Verwenden Sie ein Nicht-Basis-Image AWS

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.

Es gibt zwei Möglichkeiten, ein Container-Image für eine Go-Lambda-Funktion zu erstellen:

Verwenden eines AWS reinen Betriebssystem-Basisimages

Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie ein Basis-Image nur für das Betriebssystem, um Go-Images für Lambda zu erstellen. Um das Image mit Lambda kompatibel zu machen, müssen Sie das aws-lambda-go/lambda-Paket in das Image aufnehmen.
Verwenden Sie ein Nicht-Basis-Image AWS

Sie können auch ein alternatives Basis-Image aus einer anderen Container-Registry verwenden. Sie können auch ein von Ihrer Organisation erstelltes benutzerdefiniertes Image verwenden. Um das Image mit Lambda kompatibel zu machen, müssen Sie das aws-lambda-go/lambda-Paket in das Image aufnehmen.

Tipp

Um die Zeit zu reduzieren, die benötigt wird, bis Lambda-Container-Funktionen aktiv werden, siehe die Docker-Dokumentation unter Verwenden mehrstufiger Builds. Um effiziente Container-Images zu erstellen, folgen Sie den Bewährte Methoden für das Schreiben von Dockerfiles.

Auf dieser Seite wird erklärt, wie Sie Container-Images für Lambda erstellen, testen und bereitstellen.

AWS Basis-Images für die Bereitstellung von Go-Funktionen

Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie ein reines Betriebssystem-Basisimage, um Go-Funktionen für Lambda bereitzustellen.

Name	ID	Betriebssystem	Datum der Veraltung	Blockfunktion erstellen	Blockfunktion aktualisieren
Reine OS-Laufzeit	`provided.al2023`	Amazon Linux 2023	30. Juni 2029	31. Juli 2029	31. August 2029
Reine OS-Laufzeit	`provided.al2`	Amazon Linux 2	30. Juni 2026	31. Juli 2026	31. August 2026

Öffentliche Galerie von Amazon Elastic Container Registry: gallery.ecr. aws/lambda/provided

Laufzeitschnittstellen-Clients von Go

Das aws-lambda-go/lambda-Paket enthält eine Implementierung der Laufzeitschnittstelle. Beispiele für die Verwendung von aws-lambda-go/lambda in Ihrem Image finden Sie unter Verwenden eines AWS reinen Betriebssystem-Basisimages oder Verwenden Sie ein Nicht-Basis-Image AWS.

Verwenden eines AWS reinen Betriebssystem-Basisimages

Go wird anders implementiert als andere verwaltete Laufzeiten. Da Go nativ zu einer ausführbaren Binärdatei kompiliert wird, ist keine spezielle Sprachlaufzeit erforderlich. Verwenden Sie ein reines Betriebssystem-Basis-Image, um Container-Images für Go-Funktionen zu erstellen.

Tags	Laufzeit	Betriebssystem	Dockerfile	Ablehnung
al2023	Reine OS-Laufzeit	Amazon Linux 2023	Dockerfile für Runtime nur für Betriebssysteme aktiviert GitHub	30. Juni 2029
al2	Reine OS-Laufzeit	Amazon Linux 2	Dockerfile nur für Betriebssystem, Runtime aktiviert GitHub	30. Juni 2026

Weitere Informationen zu diesen Basis-Images finden Sie in der öffentlichen Amazon-ECR-Galerie unter provided.

Sie müssen das aws-lambda-go/lambda-Paket in Ihren Go-Handler aufnehmen. Dieses Paket implementiert das Programmiermodell für Go, einschließlich der Laufzeitschnittstelle.

Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:

AWS CLI Version 2
Docker (Mindestversion 25.0.0)
Das Docker-Buildx-Plugin.
Go

Voraussetzungen

Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:

AWS CLI Version 2
Docker (Mindestversion 25.0.0)
Das Docker-Buildx-Plugin.
Go

So erstellen und implementieren Sie eine Go-Funktion mit dem `provided.al2023`-Basis-Image.

Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir hello
cd hello
```
Initialisieren Sie ein neues Go-Modul.
```
go mod init example.com/hello-world
```
Fügen Sie die Lambda-Bibliothek als Abhängigkeit Ihres neuen Moduls hinzu.
```
go get github.com/aws/aws-lambda-go/lambda
```

Erstellen Sie eine Datei namens main.go und öffnen Sie diese dann in einem Text-Editor. Dies ist der Code für die Lambda-Funktion. Sie können den folgenden Beispielcode zum Testen verwenden oder ihn durch Ihren eigenen ersetzen.


package main

import (
	"context"
	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	response := events.APIGatewayProxyResponse{
		StatusCode: 200,
		Body:       "\"Hello from Lambda!\"",
	}
	return response, nil
}

func main() {
	lambda.Start(handler)
}

Verwenden Sie einen Texteditor, um ein Dockerfile in Ihrem Projektverzeichnis zu erstellen.
- Die folgende Beispiel-Docker-Datei verwendet eine mehrstufige Entwicklung. Dadurch können Sie in jedem Schritt ein anderes Basis-Image verwenden. Sie können ein Image verwenden, z. B. ein Go-Basis-Image, um Ihren Code zu kompilieren und die ausführbare Binärdatei zu erstellen. Sie können dann ein anderes Image verwenden, z. B. provided.al2023 in der FROM-Abschlusserklärung, um das Image zu definieren, das Sie für Lambda bereitstellen. Der Build-Prozess ist vom endgültigen Bereitstellungs-Image getrennt, so dass das endgültige Image nur die Dateien enthält, die zum Ausführen der Anwendung benötigt werden.
- Sie können das optionale Tag lambda.norpc verwenden, um die RPC-Komponente (Remote Procedure Call, Remoteprozeduraufruf) der Bibliothek lambda auszuschließen. Die RPC-Komponente ist nur erforderlich, wenn Sie die veraltete Go 1.x-Laufzeit verwenden. Durch Ausschließen der RPC-Komponente verringert sich die Größe des Bereitstellungspakets.
- Beachten Sie, dass das Dockerfile-Beispiel keine USER-Anweisung enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der root-Benutzer verwendet wird, wenn keine USER-Anweisung bereitgestellt wird.
Beispiel – Mehrstufige Docker-Datei
Anmerkung
Stellen Sie sicher, dass die Version von Go, die Sie in der Docker-Datei angeben (z. B. golang:1.20), dieselbe Version von Go ist, mit der Sie Ihre Anwendung erstellt haben.
```
FROM golang:1.20 as build
WORKDIR /helloworld
# Copy dependencies list
COPY go.mod go.sum ./
# Build with optional lambda.norpc tag
COPY main.go .
RUN go build -tags lambda.norpc -o main main.go
# Copy artifacts to a clean image
FROM public.ecr.aws/lambda/provided:al2023
COPY --from=build /helloworld/main ./main
ENTRYPOINT [ "./main" ]
```
Erstellen Sie Ihr Docker-Image mit dem docker build-Befehl. Das folgende Beispiel benennt das Bild in docker-image und gibt ihm den test Tag. Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die --provenance=false Option verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
Anmerkung
Der Befehl gibt die --platform linux/amd64-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die --platform linux/arm64 Option verwendet.

Erstellen eines Images aus dem Basis-Image „provided.al2023“

So erstellen und implementieren Sie eine Go-Funktion mit dem `provided.al2023`-Basis-Image.

Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir hello
cd hello
```
Initialisieren Sie ein neues Go-Modul.
```
go mod init example.com/hello-world
```
Fügen Sie die Lambda-Bibliothek als Abhängigkeit Ihres neuen Moduls hinzu.
```
go get github.com/aws/aws-lambda-go/lambda
```


package main

import (
	"context"
	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	response := events.APIGatewayProxyResponse{
		StatusCode: 200,
		Body:       "\"Hello from Lambda!\"",
	}
	return response, nil
}

func main() {
	lambda.Start(handler)
}

Verwenden Sie einen Texteditor, um ein Dockerfile in Ihrem Projektverzeichnis zu erstellen.
- Die folgende Beispiel-Docker-Datei verwendet eine mehrstufige Entwicklung. Dadurch können Sie in jedem Schritt ein anderes Basis-Image verwenden. Sie können ein Image verwenden, z. B. ein Go-Basis-Image, um Ihren Code zu kompilieren und die ausführbare Binärdatei zu erstellen. Sie können dann ein anderes Image verwenden, z. B. provided.al2023 in der FROM-Abschlusserklärung, um das Image zu definieren, das Sie für Lambda bereitstellen. Der Build-Prozess ist vom endgültigen Bereitstellungs-Image getrennt, so dass das endgültige Image nur die Dateien enthält, die zum Ausführen der Anwendung benötigt werden.
- Sie können das optionale Tag lambda.norpc verwenden, um die RPC-Komponente (Remote Procedure Call, Remoteprozeduraufruf) der Bibliothek lambda auszuschließen. Die RPC-Komponente ist nur erforderlich, wenn Sie die veraltete Go 1.x-Laufzeit verwenden. Durch Ausschließen der RPC-Komponente verringert sich die Größe des Bereitstellungspakets.
- Beachten Sie, dass das Dockerfile-Beispiel keine USER-Anweisung enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der root-Benutzer verwendet wird, wenn keine USER-Anweisung bereitgestellt wird.
Beispiel – Mehrstufige Docker-Datei
Anmerkung
Stellen Sie sicher, dass die Version von Go, die Sie in der Docker-Datei angeben (z. B. golang:1.20), dieselbe Version von Go ist, mit der Sie Ihre Anwendung erstellt haben.
```
FROM golang:1.20 as build
WORKDIR /helloworld
# Copy dependencies list
COPY go.mod go.sum ./
# Build with optional lambda.norpc tag
COPY main.go .
RUN go build -tags lambda.norpc -o main main.go
# Copy artifacts to a clean image
FROM public.ecr.aws/lambda/provided:al2023
COPY --from=build /helloworld/main ./main
ENTRYPOINT [ "./main" ]
```
Erstellen Sie Ihr Docker-Image mit dem docker build-Befehl. Das folgende Beispiel benennt das Bild in docker-image und gibt ihm den test Tag. Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die --provenance=false Option verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
Anmerkung
Der Befehl gibt die --platform linux/amd64-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die --platform linux/arm64 Option verwendet.

Verwenden Sie den Laufzeit-Schnittstellen-Emulator, um Ihr Image lokal zu testen. Der Laufzeit-Schnittstellen-Emulator ist im provided.al2023-Basis-Image enthalten.

So führen Sie den Laufzeit-Schnittstellen-Emulator auf Ihrem lokalen Computer aus

Starten Sie Ihr Docker-Image mit dem docker run-Befehl. Beachten Sie Folgendes:
- docker-image ist der Image-Name und test ist das Tag.
- ./main ist ENTRYPOINT aus Ihrem Dockerfile.
```
docker run -d -p 9000:8080 \
--entrypoint /usr/local/bin/aws-lambda-rie \
docker-image:test ./main
```
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei localhost:9000/2015-03-31/functions/function/invocations.
Veröffentlichen Sie in einem neuen Terminalfenster ein Ereignis mit einem curl-Befehl an den folgenden Endpunkt:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Für einige Funktionen ist möglicherweise eine JSON-Nutzlast erforderlich. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
Die Container-ID erhalten.
```
docker ps
```
Verwenden Sie den Befehl docker kill, um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl 3766c4ab331c durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```

(Optional) Testen Sie das Image lokal

Verwenden Sie den Laufzeit-Schnittstellen-Emulator, um Ihr Image lokal zu testen. Der Laufzeit-Schnittstellen-Emulator ist im provided.al2023-Basis-Image enthalten.

So führen Sie den Laufzeit-Schnittstellen-Emulator auf Ihrem lokalen Computer aus

Starten Sie Ihr Docker-Image mit dem docker run-Befehl. Beachten Sie Folgendes:
- docker-image ist der Image-Name und test ist das Tag.
- ./main ist ENTRYPOINT aus Ihrem Dockerfile.
```
docker run -d -p 9000:8080 \
--entrypoint /usr/local/bin/aws-lambda-rie \
docker-image:test ./main
```
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei localhost:9000/2015-03-31/functions/function/invocations.
Veröffentlichen Sie in einem neuen Terminalfenster ein Ereignis mit einem curl-Befehl an den folgenden Endpunkt:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Für einige Funktionen ist möglicherweise eine JSON-Nutzlast erforderlich. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
Die Container-ID erhalten.
```
docker ps
```
Verwenden Sie den Befehl docker kill, um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl 3766c4ab331c durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```

Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen

Führen Sie den get-login-passwordBefehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
- Setzen Sie den --region Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
- Ersetzen Sie es 111122223333 durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```

Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls create-repository.


aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

Anmerkung

Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.

Wenn erfolgreich, sehen Sie eine Antwort wie diese:


{
    "repository": {
        "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
        "registryId": "111122223333",
        "repositoryName": "hello-world",
        "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
        "createdAt": "2023-03-09T10:39:01+00:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}

Kopieren Sie das repositoryUri aus der Ausgabe im vorherigen Schritt.
Führen Sie den Befehl docker tag aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
- docker-image:test ist der Name und das Tag Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im docker build-Befehl angegeben haben.
- Ersetzen Sie <ECRrepositoryUri> durch den repositoryUri, den Sie kopiert haben. Stellen Sie sicher, dass Sie :latest am Ende der URI angeben.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Führen Sie den Befehl docker push aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie :latest am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Erstellen Sie eine Ausführungsrolle für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
So erstellen Sie die Lambda-Funktion: Geben Sie für ImageUri die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie :latest am Ende der URI angeben.
```
aws lambda create-function \
  --function-name hello-world \
  --package-type Image \
  --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --role arn:aws:iam::111122223333:role/lambda-ex
```
Anmerkung
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter Kontoübergreifende Berechtigungen von Amazon ECR.

Die Funktion aufrufen.


aws lambda invoke --function-name hello-world response.json

Das Ergebnis sollte ungefähr wie folgt aussehen:


{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

Um die Ausgabe der Funktion zu sehen, überprüfen Sie die response.json-Datei.

Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den update-function-codeBefehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.

Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.

Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den update-function-codeBefehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die --publish-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.


aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish

Das Image bereitstellen

Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen

Führen Sie den get-login-passwordBefehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
- Setzen Sie den --region Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
- Ersetzen Sie es 111122223333 durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```

Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls create-repository.


aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

Anmerkung

Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.

Wenn erfolgreich, sehen Sie eine Antwort wie diese:


{
    "repository": {
        "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
        "registryId": "111122223333",
        "repositoryName": "hello-world",
        "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
        "createdAt": "2023-03-09T10:39:01+00:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}

Kopieren Sie das repositoryUri aus der Ausgabe im vorherigen Schritt.
Führen Sie den Befehl docker tag aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
- docker-image:test ist der Name und das Tag Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im docker build-Befehl angegeben haben.
- Ersetzen Sie <ECRrepositoryUri> durch den repositoryUri, den Sie kopiert haben. Stellen Sie sicher, dass Sie :latest am Ende der URI angeben.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Führen Sie den Befehl docker push aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie :latest am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Erstellen Sie eine Ausführungsrolle für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
So erstellen Sie die Lambda-Funktion: Geben Sie für ImageUri die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie :latest am Ende der URI angeben.
```
aws lambda create-function \
  --function-name hello-world \
  --package-type Image \
  --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --role arn:aws:iam::111122223333:role/lambda-ex
```
Anmerkung
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter Kontoübergreifende Berechtigungen von Amazon ECR.

Die Funktion aufrufen.


aws lambda invoke --function-name hello-world response.json

Das Ergebnis sollte ungefähr wie folgt aussehen:


{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

Um die Ausgabe der Funktion zu sehen, überprüfen Sie die response.json-Datei.


aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish

Verwenden Sie ein Nicht-Basis-Image AWS

Sie können ein Container-Image für Go aus einem AWS Nicht-Base-Image erstellen. Das Beispiel-Dockerfile in den folgenden Schritten verwendet ein Alpine-Basis-Image.

Sie müssen das Paket aws-lambda-go/lambda in Ihren Go-Handler aufnehmen. Dieses Paket implementiert das Programmiermodell für Go, einschließlich der Laufzeitschnittstelle.

Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:

AWS CLI Version 2
Docker (Mindestversion 25.0.0)
Das Docker-Buildx-Plugin.
Go

Voraussetzungen

Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:

AWS CLI Version 2
Docker (Mindestversion 25.0.0)
Das Docker-Buildx-Plugin.
Go

Erstellen und Bereitstellen einer Go-Funktion mit einem Alpine-Basis-Image

Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir hello
cd hello
```
Initialisieren Sie ein neues Go-Modul.
```
go mod init example.com/hello-world
```
Fügen Sie die Lambda-Bibliothek als Abhängigkeit Ihres neuen Moduls hinzu.
```
go get github.com/aws/aws-lambda-go/lambda
```


package main

import (
	"context"
	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	response := events.APIGatewayProxyResponse{
		StatusCode: 200,
		Body:       "\"Hello from Lambda!\"",
	}
	return response, nil
}

func main() {
	lambda.Start(handler)
}

Verwenden Sie einen Texteditor, um ein Dockerfile in Ihrem Projektverzeichnis zu erstellen. Das folgende Beispiel-Dockerfile verwendet ein Alpine-Basis-Image. Beachten Sie, dass das Dockerfile-Beispiel keine USER-Anweisung enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der root-Benutzer verwendet wird, wenn keine USER-Anweisung bereitgestellt wird.

Beispiel Dockerfile
Anmerkung
Stellen Sie sicher, dass die Version von Go, die Sie in der Docker-Datei angeben (z. B. golang:1.20), dieselbe Version von Go ist, mit der Sie Ihre Anwendung erstellt haben.
```
FROM golang:1.20.2-alpine3.16 as build
WORKDIR /helloworld
# Copy dependencies list
COPY go.mod go.sum ./
# Build
COPY main.go .
RUN go build -o main main.go
# Copy artifacts to a clean image
FROM alpine:3.16
COPY --from=build /helloworld/main /main
ENTRYPOINT [ "/main" ]
```
Erstellen Sie Ihr Docker-Image mit dem docker build-Befehl. Das folgende Beispiel benennt das Bild in docker-image und gibt ihm den test Tag. Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die --provenance=false Option verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
Anmerkung
Der Befehl gibt die --platform linux/amd64-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die --platform linux/arm64 Option verwendet.

Erstellen eines Images aus einem alternativen Basis-Image

Erstellen und Bereitstellen einer Go-Funktion mit einem Alpine-Basis-Image

Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir hello
cd hello
```
Initialisieren Sie ein neues Go-Modul.
```
go mod init example.com/hello-world
```
Fügen Sie die Lambda-Bibliothek als Abhängigkeit Ihres neuen Moduls hinzu.
```
go get github.com/aws/aws-lambda-go/lambda
```


package main

import (
	"context"
	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	response := events.APIGatewayProxyResponse{
		StatusCode: 200,
		Body:       "\"Hello from Lambda!\"",
	}
	return response, nil
}

func main() {
	lambda.Start(handler)
}

Verwenden Sie einen Texteditor, um ein Dockerfile in Ihrem Projektverzeichnis zu erstellen. Das folgende Beispiel-Dockerfile verwendet ein Alpine-Basis-Image. Beachten Sie, dass das Dockerfile-Beispiel keine USER-Anweisung enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der root-Benutzer verwendet wird, wenn keine USER-Anweisung bereitgestellt wird.

Beispiel Dockerfile
Anmerkung
Stellen Sie sicher, dass die Version von Go, die Sie in der Docker-Datei angeben (z. B. golang:1.20), dieselbe Version von Go ist, mit der Sie Ihre Anwendung erstellt haben.
```
FROM golang:1.20.2-alpine3.16 as build
WORKDIR /helloworld
# Copy dependencies list
COPY go.mod go.sum ./
# Build
COPY main.go .
RUN go build -o main main.go
# Copy artifacts to a clean image
FROM alpine:3.16
COPY --from=build /helloworld/main /main
ENTRYPOINT [ "/main" ]
```
Erstellen Sie Ihr Docker-Image mit dem docker build-Befehl. Das folgende Beispiel benennt das Bild in docker-image und gibt ihm den test Tag. Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die --provenance=false Option verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
Anmerkung
Der Befehl gibt die --platform linux/amd64-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die --platform linux/arm64 Option verwendet.

Verwenden Sie den Laufzeit-Schnittstellen-Emulator, um das Image lokal zu testen. Sie können den Emulator in Ihr Image integrieren oder ihn mit dem folgenden Verfahren auf Ihrem lokalen Computer installieren.

Installieren des Laufzeitschnittstellen-Emulators auf Ihrem lokalen Computer

Führen Sie in Ihrem Projektverzeichnis den folgenden Befehl aus, um den Runtime-Interface-Emulator (x86-64-Architektur) herunterzuladen GitHub und auf Ihrem lokalen Computer zu installieren.

Starten Sie Ihr Docker-Image mit dem docker run-Befehl. Beachten Sie Folgendes:
- docker-image ist der Image-Name und test ist das Tag.
- /main ist ENTRYPOINT aus Ihrem Dockerfile.
Linux/macOS
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
    --entrypoint /aws-lambda/aws-lambda-rie \
    docker-image:test \
        /main
```
PowerShell
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
    /main
```
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei localhost:9000/2015-03-31/functions/function/invocations.

Anmerkung
Wenn Sie das Docker-Image für die ARM64 Befehlssatzarchitektur erstellt haben, stellen Sie sicher, dass Sie die --platform linux/arm64 Option anstelle von verwenden. --platform linux/amd64
Veröffentlichen Sie ein Ereignis auf dem lokalen Endpunkt.
Linux/macOS
Führen Sie unter Linux oder macOS den folgenden curl-Befehl aus:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
PowerShell
Führen Sie in PowerShell den folgenden Invoke-WebRequest Befehl aus:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
Die Container-ID erhalten.
```
docker ps
```
Verwenden Sie den Befehl docker kill, um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl 3766c4ab331c durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```

(Optional) Testen Sie das Image lokal

Installieren des Laufzeitschnittstellen-Emulators auf Ihrem lokalen Computer

Führen Sie in Ihrem Projektverzeichnis den folgenden Befehl aus, um den Runtime-Interface-Emulator (x86-64-Architektur) herunterzuladen GitHub und auf Ihrem lokalen Computer zu installieren.

anchor anchor


mkdir -p ~/.aws-lambda-rie && \
    curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
    chmod +x ~/.aws-lambda-rie/aws-lambda-rie

Um den arm64-Emulator zu installieren, ersetzen Sie die GitHub Repository-URL im vorherigen Befehl durch Folgendes:


https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64

Starten Sie Ihr Docker-Image mit dem docker run-Befehl. Beachten Sie Folgendes:
- docker-image ist der Image-Name und test ist das Tag.
- /main ist ENTRYPOINT aus Ihrem Dockerfile.
Linux/macOS
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
    --entrypoint /aws-lambda/aws-lambda-rie \
    docker-image:test \
        /main
```
PowerShell
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
    /main
```
anchor anchor
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \ --entrypoint /aws-lambda/aws-lambda-rie \ docker-image:test \ /main
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei localhost:9000/2015-03-31/functions/function/invocations.

Anmerkung
Wenn Sie das Docker-Image für die ARM64 Befehlssatzarchitektur erstellt haben, stellen Sie sicher, dass Sie die --platform linux/arm64 Option anstelle von verwenden. --platform linux/amd64
Veröffentlichen Sie ein Ereignis auf dem lokalen Endpunkt.
Linux/macOS
Führen Sie unter Linux oder macOS den folgenden curl-Befehl aus:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
PowerShell
Führen Sie in PowerShell den folgenden Invoke-WebRequest Befehl aus:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
anchor anchor
Führen Sie unter Linux oder macOS den folgenden curl-Befehl aus:

curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'

Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:

curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
Die Container-ID erhalten.
```
docker ps
```
Verwenden Sie den Befehl docker kill, um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl 3766c4ab331c durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```

Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen

Führen Sie den get-login-passwordBefehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
- Setzen Sie den --region Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
- Ersetzen Sie es 111122223333 durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```

Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls create-repository.


aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

Anmerkung

Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.

Wenn erfolgreich, sehen Sie eine Antwort wie diese:


{
    "repository": {
        "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
        "registryId": "111122223333",
        "repositoryName": "hello-world",
        "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
        "createdAt": "2023-03-09T10:39:01+00:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}

Kopieren Sie das repositoryUri aus der Ausgabe im vorherigen Schritt.
Führen Sie den Befehl docker tag aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
- docker-image:test ist der Name und das Tag Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im docker build-Befehl angegeben haben.
- Ersetzen Sie <ECRrepositoryUri> durch den repositoryUri, den Sie kopiert haben. Stellen Sie sicher, dass Sie :latest am Ende der URI angeben.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Führen Sie den Befehl docker push aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie :latest am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Erstellen Sie eine Ausführungsrolle für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
So erstellen Sie die Lambda-Funktion: Geben Sie für ImageUri die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie :latest am Ende der URI angeben.
```
aws lambda create-function \
  --function-name hello-world \
  --package-type Image \
  --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --role arn:aws:iam::111122223333:role/lambda-ex
```
Anmerkung
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter Kontoübergreifende Berechtigungen von Amazon ECR.

Die Funktion aufrufen.


aws lambda invoke --function-name hello-world response.json

Das Ergebnis sollte ungefähr wie folgt aussehen:


{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

Um die Ausgabe der Funktion zu sehen, überprüfen Sie die response.json-Datei.


aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish

Das Image bereitstellen

Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen

Führen Sie den get-login-passwordBefehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
- Setzen Sie den --region Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
- Ersetzen Sie es 111122223333 durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```

Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls create-repository.


aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

Anmerkung

Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.

Wenn erfolgreich, sehen Sie eine Antwort wie diese:


{
    "repository": {
        "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
        "registryId": "111122223333",
        "repositoryName": "hello-world",
        "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
        "createdAt": "2023-03-09T10:39:01+00:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}

Kopieren Sie das repositoryUri aus der Ausgabe im vorherigen Schritt.
Führen Sie den Befehl docker tag aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
- docker-image:test ist der Name und das Tag Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im docker build-Befehl angegeben haben.
- Ersetzen Sie <ECRrepositoryUri> durch den repositoryUri, den Sie kopiert haben. Stellen Sie sicher, dass Sie :latest am Ende der URI angeben.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Führen Sie den Befehl docker push aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie :latest am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Erstellen Sie eine Ausführungsrolle für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
So erstellen Sie die Lambda-Funktion: Geben Sie für ImageUri die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie :latest am Ende der URI angeben.
```
aws lambda create-function \
  --function-name hello-world \
  --package-type Image \
  --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --role arn:aws:iam::111122223333:role/lambda-ex
```
Anmerkung
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter Kontoübergreifende Berechtigungen von Amazon ECR.

Die Funktion aufrufen.


aws lambda invoke --function-name hello-world response.json

Das Ergebnis sollte ungefähr wie folgt aussehen:


{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

Um die Ausgabe der Funktion zu sehen, überprüfen Sie die response.json-Datei.


aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Bereitstellen von ZIP-Dateiarchiven

Ebenen

Auf dieser Seite

Wählen Sie Ihre Cookie-Einstellungen aus

Bereitstellen von Go-Lambda-Funktionen mit Container-Images

Tipp

AWS Basis-Images für die Bereitstellung von Go-Funktionen

Laufzeitschnittstellen-Clients von Go

Verwenden eines AWS reinen Betriebssystem-Basisimages

Voraussetzungen

So erstellen und implementieren Sie eine Go-Funktion mit dem provided.al2023-Basis-Image.

Beispiel – Mehrstufige Docker-Datei

Anmerkung

Anmerkung

Erstellen eines Images aus dem Basis-Image „provided.al2023“

So erstellen und implementieren Sie eine Go-Funktion mit dem provided.al2023-Basis-Image.

Beispiel – Mehrstufige Docker-Datei

Anmerkung

Anmerkung

So führen Sie den Laufzeit-Schnittstellen-Emulator auf Ihrem lokalen Computer aus

(Optional) Testen Sie das Image lokal

So führen Sie den Laufzeit-Schnittstellen-Emulator auf Ihrem lokalen Computer aus

Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen

Anmerkung

Anmerkung

Das Image bereitstellen

Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen

Anmerkung

Anmerkung

Verwenden Sie ein Nicht-Basis-Image AWS

Voraussetzungen

Erstellen und Bereitstellen einer Go-Funktion mit einem Alpine-Basis-Image

Beispiel Dockerfile

Anmerkung

Anmerkung

Erstellen eines Images aus einem alternativen Basis-Image

Erstellen und Bereitstellen einer Go-Funktion mit einem Alpine-Basis-Image

Beispiel Dockerfile

Anmerkung

Anmerkung

Installieren des Laufzeitschnittstellen-Emulators auf Ihrem lokalen Computer

Anmerkung

(Optional) Testen Sie das Image lokal

Installieren des Laufzeitschnittstellen-Emulators auf Ihrem lokalen Computer

Anmerkung

Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen

Anmerkung

Anmerkung

Das Image bereitstellen

Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen

Anmerkung

Anmerkung

Auf dieser Seite

Related resources

Hat Ihnen diese Seite geholfen?

Related resources

Nächstes Thema:

Vorheriges Thema:

Brauchen Sie Hilfe?

So erstellen und implementieren Sie eine Go-Funktion mit dem `provided.al2023`-Basis-Image.

So erstellen und implementieren Sie eine Go-Funktion mit dem `provided.al2023`-Basis-Image.