[DOCKER] Führen Sie C-Binärdateien auf AWS Lambda aus

Es ist eine triviale Angelegenheit, aber ich habe versucht, C mit Lambdas benutzerdefinierter Laufzeit auszuführen.

Verzeichnisaufbau

.
├── bin
│   ├── bootstrap
│   └── lambda_function
├── docker-compose.yml
├── Dockerfile
└── src
    ├── lambda_function.c
    └── Makefile

Eine Reihe von Codes finden Sie unter https://github.com/tsubasaogawa/lambda-with-c.

Verfahren

Überblick

1. Schreiben Sie die C-Quelle
2. Kompilieren Sie die Quelle in derselben Ausführungsumgebung wie Lambda
3. Bootstrap reparieren
4. Auf Lambda hochladen

Einzelheiten

Schreiben Sie eine C-Quelle

Schreiben Sie die Quelle wie gewohnt. Dieses Mal habe ich eine einfache erstellt, die nur "den Standardeingabeinhalt ausgibt".

lambda_function.c

#include <stdio.h>

int main(void) {
  char buf[512];

  while(1) {
    /* Obtain from Stdin https://qiita.com/mpyw/items/aff12a6ff2c7726ed1d8 */
    if(scanf("%511[^\n]%*[^\n]", buf) != 1) {
      break;
    }
    /* Ignore linefeed */
    scanf("%*c");

    printf("%s\n", buf);
  }

  return 0;
}

Makefile

PROGRAM = lambda_function
CC = gcc
CFLAGS = -Wall
OBJS = $(PROGRAM).o

$(PROGRAM): $(OBJS)
	$(CC) $(CFLAGS) -o $(PROGRAM) $(OBJS)

$(OBJS): $(PROGRAM).c
	$(CC) -c $(PROGRAM).c

.PHONY: clean
clean:
	rm -f $(PROGRAM) $(OBJS)

.PHONY: clean_obj
clean_obj:
	rm -f $(OBJS)

Kompilieren Sie die Quelle in derselben Ausführungsumgebung wie Lambda

Es läuft auf Lambda, daher müssen Sie es in derselben Umgebung wie Lambda kompilieren. Laut Lambda-Ausführungsumgebung und verfügbaren Bibliotheken verwende ich Amazon Linux (2019/02). Jetzt, da wir es wissen, werden wir es auf einem Amazon Linux-Container kompilieren.

Dockerfile

FROM amazonlinux:2
MAINTAINER tsubasaogawa

WORKDIR /usr/local/src/lambda-with-c

RUN set -x && yum install -y gcc make

# ADD ./bootstrap .
COPY ./src/lambda_function.c .
COPY ./src/Makefile .

RUN make && make clean_obj

Ich habe es geschafft, zu Amazon Linux 2 zu wechseln. Docker-Compose ist unten.

docker-compose.yml

version: '3'
services:
  lambda-with-c-compiler:
    build: .
    volumes:
      - ./bin:/var/tmp
    command: /bin/bash -c 'cp -r /usr/local/src/lambda-with-c/lambda_function /var/tmp'

Die von make zum Zeitpunkt der Containererstellung erstellte Binärdatei wird in das gemountete Verzeichnis kopiert. Wenn der Container ausgeführt wird, wird auf dem Host unter bin / eine Binärdatei erstellt.

$ docker-compose build
$ docker-compose up -d
$ ls -l bin/lambda_function
-rwxr-xr-x 1 root root 8232 Feb 11 12:49 bin/lambda_function

Bootstrap reparieren

Die benutzerdefinierte Laufzeit führt eine Datei namens "Bootstrap" aus. Es ist wie das Ausführen einer Binärdatei über Bootstrap. In Tutorial wird Bootstrap in einem Shell-Skript geschrieben. Dies wird teilweise (oder fast) umgeleitet.

bootstrap

#!/bin/sh

set -euo pipefail

# Processing
while true
do
  HEADERS="$(mktemp)"
  # Get an event
  EVENT_DATA=$(curl -sS -LD "$HEADERS" -X GET "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/next")
  REQUEST_ID=$(grep -Fi Lambda-Runtime-Aws-Request-Id "$HEADERS" | tr -d '[:space:]' | cut -d: -f2)

  # Execute the handler function from the script
  EXEC="$LAMBDA_TASK_ROOT/$(echo "$_HANDLER" | cut -d. -f1)"
  RESPONSE=$(echo "$EVENT_DATA" | $EXEC)

  # Send the response
  curl -X POST "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/$REQUEST_ID/response"  -d "$RESPONSE"
done

Auf Lambda hochladen

Reißverschluss des Artefakts und lade es auf Lambda hoch. Bitte bereiten Sie im Voraus eine entsprechende Rolle vor.

Auf Lambda hochladen

$ cd bin
$ zip ../lambda_function.zip ./*
$ cd ..
$ ls -l lambda_function.zip 
-rw-rw-r-- 1 vagrant vagrant 3032 Feb 11 12:55 lambda_function.zip

$ aws lambda create-function --function-name lambda-with-c \
    --zip-file fileb://lambda_function.zip --handler lambda_function.handler \
    --runtime provided --role arn:aws:iam::***:role/role_name

Ich werde es versuchen.

Lauf

$ aws lambda invoke --function-name lambda-with-c \
    --invocation-type RequestResponse \
    --payload '{ "test1": "value1" }' \
    /tmp/lambda-with-c.log
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}

Ausführungsergebnis

$ cat /tmp/lambda-with-c.log 
{
    "test1": "value1"
}

Sieht gut aus. Nachdem wir die Argumente haben, können wir sie frei analysieren und verwenden.

abschließend

• Ich habe versucht, eine in C erstellte Binärdatei mit Lambdas benutzerdefinierter Laufzeit auszuführen.
• Zuverlässig zu kompilieren unter Amazon Linux
• Wenn Sie eine benutzerdefinierte Laufzeit verwenden, wird zuerst eine Datei namens Bootstrap ausgeführt
• Führen Sie die Binärdatei über Bootstrap aus ―― Darüber hinaus verfügt C ++ über eine praktische Bibliothek, sodass Sie sich freuen können, wenn Sie sie verwenden.
• https://github.com/awslabs/aws-lambda-cpp
• Referenzartikel
• https://dev.classmethod.jp/cloud/aws/lambda-custom-runtimes-c/