
## 概要

Lambda の Python ランタイムから OpenCV モジュールを利用できるようにするため、Lambda レイヤーに OpenCV を追加します。

## 構築環境

```bash
$ python -V
Python 3.9.12
$ pip -V
pip 22.0.4 from /home/ec2-user/.anyenv/envs/pyenv/versions/3.9.12/lib/python3.9/site-packages/pip (python 3.9)
```

## Lambda レイヤーに OpenCV モジュールを追加する手順

### 作業用ディレクトリとレイヤーパスの作成

```bash
mkdir -p ~/opencv_layer/python
```

### OpenCV 　(opencv-python) のインストール

`python` ディレクトリに `opencv-python` をインストールします。

```bash
$ cd ~/opencv_layer
$ pip install opencv-python -t python
Collecting opencv-python
  Using cached opencv_python-4.5.5.64-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (60.5 MB)
Collecting numpy>=1.17.3
  Using cached numpy-1.22.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.8 MB)
Installing collected packages: numpy, opencv-python
Successfully installed numpy-1.22.3 opencv-python-4.5.5.64
```

### mesa-libGL のインストール

現状、`opencv-python` をインストールしたディレクトリをプロイパッケージ化 (zip ファイルアーカイブ) して、Lambda レイヤーを作成して `cv2` を `import` すると以下のようなエラーが発生します。

```text
[ERROR] Runtime.ImportModuleError: Unable to import module 'lambda_function': libGL.so.1: cannot open shared object file: No such file or directory
```

既知の問題みたいで以下のサイトを参考に対応していきます。

<https://stackoverflow.com/questions/64016819/cant-use-opencv-python-in-aws-lambda>

まず、`mesa-libGL` をインストールします。

```bash
sudo yum install -y mesa-libGL
```

`mesa-libGL` をインストール後に、必要なライブラリを `python` ディレクトリに追加します。

```bash
cd ~/opencv_layer
cp -v /usr/lib64/libGL.so.1 ./python/opencv_python.libs/
cp -v /usr/lib64/libgthread-2.0.so.0 ./python/opencv_python.libs/
cp -v /usr/lib64/libglib-2.0.so.0 ./python/opencv_python.libs/
cp -v /usr/lib64/libGLX.so.0 ./python/opencv_python.libs/
cp -v /usr/lib64/libX11.so.6 ./python/opencv_python.libs/
cp -v /usr/lib64/libXext.so.6 ./python/opencv_python.libs/
cp -v /usr/lib64/libGLdispatch.so.0 ./python/opencv_python.libs/
cp -v /usr/lib64/libGLX_mesa.so.0.0.0 ./python/opencv_python.libs/
cp -v /usr/lib64/libxcb.so.1 ./python/opencv_python.libs/
cp -v /usr/lib64/libXau.so.6 ./python/opencv_python.libs/
cp -v /lib64/libGLdispatch.so.0.0.0 ./python/opencv_python.libs/
```

### 軽量化のために不要なファイルを削除する

そのままだと、236 MB もあるので不要なファイルを削除して少しでも軽くします。

```bash
$ du -sh python/
236M    python/
```

`Serverless Framework` の [Slim Package][^1] を参考に `dist-info`、`__pycache__`、`pyc`、`pyo` を削除します。

[^1]: [Serverless Framework: Plugins](https://www.serverless.com/plugins/serverless-python-requirements)

```bash
find ./python -type d -regextype posix-basic -regex ".*dist-info.*" | xargs rm -rf
find ./python -type d -regextype posix-basic -regex ".*__pycache__.*" | xargs rm -rf
find ./python -type f -regextype posix-basic -regex ".*\.py[c|o]" | xargs rm -rf
```

8 MB だけ軽くなりました。。。

```bash
$ du -sh python/
228M    python/
```

:::warning
軽量化とは別ですが、オブジェクトファイルからのシンボルテーブルなどを削除する `strip` コマンドを実行したデプロイパッケージを使用すると以下のようなエラーが発生しますので、やらないようにしましょう。

```bash
[ERROR] Runtime.ImportModuleError: Unable to import module 'lambda_function': /opt/python/cv2/cv2.abi3.so: ELF load command address/offset not properly aligned
```

:::

### デプロイパッケージ化 (zip ファイルアーカイブ)

```bash
cd ~/opencv_layer
zip -r9 opencv_layer.zip python
```

### 不要なファイルを削除して軽量化する

### Lambda レイヤーの作成

デプロイパッケージを使用した Lambda レイヤーの作成手順はこちらにまとめてあります。

<https://blog.grasswake.me/tech-posts/1640005577>

## 動作確認

作成した Lambda レイヤーを使用する Lambda 関数を作成し、テスト実行してみます。
特にエラーが発生せず、実行結果のログに `cv2` モジュール内で定義されている関数、属性などの一覧が表示されていれば成功です。

```python
import cv2

def lambda_handler(event, context):
        print(dir(cv2))
```

## Lambda レイヤーに ライブラリを追加する ( OpenCV 編)　まとめ

`opencv-python` をインストールしただけでも 236 MB にもなります。
2022/04 時点では、Lambda デプロイパッケージ (zip ファイルアーカイブ) の上限サイズは 250 MB (解凍後)[^2] です。
かなりギリギリで、`opencv-python` 以外のモジュールを追加するのも難しいです。
`opencv-contrib-python` なんて入りません。
どうしても Lambda で `opencv` を使用する場合は、コードパッケージサイズの上限が 10 GB[^2] もあるコンテナイメージを使用することを検討した方良いかなと思います。

[^2]: [Lambda クォータ \- AWS Lambda](https://docs.aws.amazon.com/ja_jp/lambda/latest/dg/gettingstarted-limits.html#function-configuration-deployment-and-execution)


Lambda レイヤーにライブラリを追加する ( OpenCV 編)


Java での Lambda レイヤーを作成手順をまとめました。

## Java + Gradle で Lambda レイヤー用のデプロイパッケージを作成する環境

- macOS: Catalina (10.15.7)
- JDK: Amazon Corretto 11 (Java 11 JDK)
- Gradle: 7.4.1

## Java + Gradle で Lambda レイヤー用のデプロイパッケージを作成する際の前提

こちらの[記事](https://blog.grasswake.me/tech-posts/1647962624)で実装した Lambda 関数をサンプルとして使います。
またこれから紹介する手順は以下の 2 つに分けて説明します。

- 外部の依存関係ライブラリを Lambda レイヤーに追加する手順
- 独自ライブラリを Lambda レイヤーに追加する手順

<https://blog.grasswake.me/tech-posts/1647962624>

## Java + Gradle で外部の依存関係ライブラリを追加した Lambda レイヤー用のデプロイパッケージを作成する手順

この手順では[サンプル](https://blog.grasswake.me/tech-posts/1647962624)で使用している以下の外部ライブラリを Lambda レイヤーに追加します。

- com.google.code.gson:gson:2.9.0
- com.amazonaws:aws-lambda-java-core:1.2.1

### 作業用ディレクトリの作成とプロジェクトの初期化

作業ディレクトリを作成して、`gradle init` コマンドを実行します。
`gradle init` コマンド実行時の各設問は最初の 2 つ以外はデフォルト値にしています。

```bash
$ mkdir ~/java-layer
$ cd ~/java-layer
$ gradle init
Starting a Gradle Daemon (subsequent builds will be faster)

Select type of project to generate:
  1: basic
  2: application
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 1

Select build script DSL:
  1: Groovy
  2: Kotlin
Enter selection (default: Groovy) [1..2] 1

Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no]

Project name (default: java-layer):

> Task :init
Get more help with your project: Learn more about Gradle by exploring our samples at https://docs.gradle.org/7.4.1/samples

BUILD SUCCESSFUL in 16s
2 actionable tasks: 2 executed
```

`gradle init` コマンド実行後、ディレクトリ構成は以下のようになります。

```text
.
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle
```

### 外部ライブラリの定義とデプロイパッケージ作成タスクの定義

`build.gradle` ファイルを修正します。
`dependencies` に Lambda レイヤーに追加する外部ライブラリを定義します。
また、`task` でデプロイパッケージ(.zip ファイルアーカイブ)を作成するタスクを定義します。

外部ライブラリを保存するパスに注意してください。
Lambda のドキュメントでは以下のように記載しています。

[Lambda レイヤーの作成と共有 \- AWS Lambda](https://docs.aws.amazon.com/ja_jp/lambda/latest/dg/configuration-layers.html#configuration-layers-path)

> ライブラリの依存関係をレイヤーに含める
> Lambda ランタイムごとに、PATH 変数に /opt ディレクトリ内の特定のフォルダが含まれます。レイヤー .zip ファイルアーカイブに同じフォルダ構造を定義すると、関数コードはパスを指定しなくても、レイヤーコンテンツにアクセスできます。
> ...
> 各 Lambda ランタイムのレイヤーパス
> Java java/lib (CLASSPATH)

上記の記述のように、Lambda レイヤーにアップロードする zip ファイルアーカイブに特定のディレクトリにライブラリなどの依存関係を含めておくだけで、パスを指定しなくてもそれを利用することができます。
今回は Java なので、`java/lib` ディレクトリに外部ライブラリを保存するよう必要があります。

```groovy fn=java-layer/build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.code.gson:gson:2.9.0'
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
}

task buildZip(type: Zip) {
    into('java/lib') {
        from configurations.runtimeClasspath
    }
}

build.dependsOn buildZip
```

### デプロイパッケージの作成その 1

`gradle build` コマンドを実行してデプロイパッケージを作成します。

```bash
gradle build
```

`build/distributions` ディレクトリに zip 形式のデプロイパッケージが作成されます。
作成されたデプロイパッケージには以下のように `java/lib/` ディレクトリと外部ライブラリが格納されます。

```bash
$ unzip -l build/distributions/java-layer.zip
Archive:  build/distributions/java-layer.zip
  Length      Date    Time    Name
---------  ---------- -----   ----
        0  03-21-2022 23:02   java/
        0  03-21-2022 23:02   java/lib/
   249277  03-20-2022 23:20   java/lib/gson-2.9.0.jar
     7515  03-20-2022 22:45   java/lib/aws-lambda-java-core-1.2.1.jar
---------                     -------
   256792                     4 files
```

### Lambda レイヤーの作成と Lambda 関数への紐付け 1

作成したデプロイパッケージを使って AWS マネジメントコンソールから Lambda レイヤーを作成と Lambda 関数への紐付けすることもできますが、今回は AWS CLI を使っていきます。
まず、`publish-layer-version` コマンドで Lambda レイヤーを作成します。
次の手順で使用するので、`publish-layer-version` コマンド実行結果から `LayerVersionArn` をメモしておきましょう。

```bash
$ aws lambda publish-layer-version --layer-name java-basic-layer \
--zip-file fileb://build/distributions/java-layer.zip --compatible-runtimes java11
{
    "Content": {
        "Location": "https://awslambda-ap-ne-1-layers.s3.ap-northeast-1.amazonaws.com/xxxxxxxxxxxxx"
        "CodeSha256": "V9RhiYR2QpTQEq7mKcl3pQnn+TTvMVyUKL9pbTi7Gd4=",
        "CodeSize": 227065
    },
    "LayerArn": "arn:aws:lambda:ap-northeast-1:zzzzzzzzzzzzzz:layer:java-basic-layer",
    "LayerVersionArn": "arn:aws:lambda:ap-northeast-1:zzzzzzzzzzzzzz:layer:java-basic-layer:1",
    "Description": "",
    "CreatedDate": "2022-03-21T14:04:36.472+0000",
    "Version": 1,
    "CompatibleRuntimes": [
        "java11"
    ]
}
```

次に、作成した Lambda レイヤーを[サンプルの Lambda 関数](https://blog.grasswake.me/tech-posts/1647962624)へ紐付けします。
`--layers` オプションに先ほどメモした `LayerVersionArn` を指定します。

```bash
aws lambda update-function-configuration --function-name java-sample \
 --layers arn:aws:lambda:ap-northeast-1:zzzzzzzzzzzzzz:layer:java-basic-layer:1
```

### Lambda 関数から外部ライブラリを排除する

[サンプルの Lambda 関数](https://blog.grasswake.me/tech-posts/1647962624)のデプロイパッケージに外部ライブラリを含める必要がなくなるので、含めないように修正します。
`build.gradle` ファイルを修正します。
`task` でデプロイパッケージ(.zip ファイルアーカイブ)を作成するタスクから外部ライブラリに関連する定義を削除します。

```groovy fn=java-sample/build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.code.gson:gson:2.9.0'
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
}

task buildZip(type: Zip) {
    from compileJava
    from processResources
    // 以下の定義が不要になります。
    // into('lib') {
    //     from configurations.runtimeClasspath
    // }
}

build.dependsOn buildZip
```

### デプロイパッケージの作成その 2

`gradle build` コマンドを実行してデプロイパッケージを作成します。

```bash
gradle build
```

`build/distributions` ディレクトリに zip 形式のデプロイパッケージが作成されます。
作成されたデプロイパッケージには以下のように外部ライブラリがなくなり、クラスファイルのみが格納されます。

```bash
$ unzip -l build/distributions/java-sample.zip
Archive:  build/distributions/java-sample.zip
  Length      Date    Time    Name
---------  ---------- -----   ----
        0  03-21-2022 22:51   sample/
     2686  03-21-2022 22:51   sample/App.class
     1381  03-21-2022 22:51   previous-compilation-data.bin
---------                     -------
     4067                     3 files
```

### Lambda 関数の更新と実行その 1

作成したデプロイパッケージを使って AWS マネジメントコンソールから Lambda 関数を更新することもできますが、今回は AWS CLI を使って Lambda 関数の更新をします。

```bash
aws lambda update-function-code --function-name java-sample --zip-file fileb://build/distributions/java-sample.zip
```

Lambda 関数を実行して、エラーが出ず以下のように出力されれば成功です。
また、Lambda 関数の CloudWatch Logs のロググループに `payload` の値などが出力されているはずです。

```bash
$ aws lambda invoke --function-name java-sample  \
--payload '{"text":"Hello"}' response.txt --cli-binary-format raw-in-base64-out
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
```

## Java + Gradle で独自ライブラリを追加した Lambda レイヤー用のデプロイパッケージを作成する手順

この手順では[サンプル](https://blog.grasswake.me/tech-posts/1647962624)内のログ処理を独自ライブラリとして Lambda レイヤーに追加します。

```java fn=java-sample/src/main/java/sample/App.java
package sample;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.util.Map;

public class App implements RequestHandler<Map<String, String>, String> {
  Gson gson = new GsonBuilder().setPrettyPrinting().create();

  @Override
  public String handleRequest(Map<String, String> event, Context context) {
    String response = new String("200 OK");
    // ---ここから---
    LambdaLogger logger = context.getLogger();
    // log execution details
    logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
    logger.log("CONTEXT: " + gson.toJson(context));
    // process event
    logger.log("EVENT: " + gson.toJson(event));
    logger.log("EVENT TYPE: " + event.getClass().toString());
    // ---ここまでの処理を独自ライブラリ化します。---
    return response;
  }
}
```

### 独自ライブラリ処理の実装

まず、独自ライブラリ処理を実装するためのファイルを作成します。

```bash
cd ~/java-layer
mkdir src/main/java/sample_lib
touch src/main/java/sample_lib/Util.java
```

[サンプル](https://blog.grasswake.me/tech-posts/1647962624)内のログ処理を参考にというかほぼそのまま持ってきます。

```java fn=java-layer/src/main/java/sample_lib/Util.java
package sample_lib;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.util.Map;

public class Util {
  public static void log(Map<String, String> event, Context context) {
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    LambdaLogger logger = context.getLogger();
    // log execution details
    logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
    logger.log("CONTEXT: " + gson.toJson(context));
    // process event
    logger.log("EVENT: " + gson.toJson(event));
    logger.log("EVENT TYPE: " + event.getClass().toString());
  }
}
```

### デプロイパッケージ作成タスクに独自ライブラリを追加するように定義する

`build.gradle` ファイルを修正します。
`buildZip` タスクで外部ライブラリ(`configurations.runtimeClasspath`)に加えコンパイルした独自ライブラリ(`jar`)も Lambda レイヤーに追加するように定義します。

```groovy fn=java-layer/build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.code.gson:gson:2.9.0'
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
}

task buildZip(type: Zip) {
    into('java/lib') {
        from jar, configurations.runtimeClasspath
    }
}

build.dependsOn buildZip
```

### デプロイパッケージの作成その 3

`gradle build` コマンドを実行してデプロイパッケージを作成します。

```bash
gradle build
```

`build/distributions` ディレクトリに zip 形式のデプロイパッケージが作成されます。
作成されたデプロイパッケージには以下のように `java/lib/` ディレクトリと独自ライブラリ(`java-layer.jar`)と外部ライブラリが格納されます。

```bash
$ unzip -l build/distributions/java-layer.zip
Archive:  build/distributions/java-layer.zip
  Length      Date    Time    Name
---------  ---------- -----   ----
        0  03-21-2022 23:17   java/
        0  03-21-2022 23:17   java/lib/
     1446  03-21-2022 23:17   java/lib/java-layer.jar
   249277  03-20-2022 23:20   java/lib/gson-2.9.0.jar
     7515  03-20-2022 22:45   java/lib/aws-lambda-java-core-1.2.1.jar
---------                     -------
   258238                     5 files
```

### Lambda レイヤーの更新と Lambda 関数への紐付け 2

作成したデプロイパッケージを使って AWS マネジメントコンソールから Lambda レイヤーの更新と Lambda 関数への紐付けすることもできますが、今回は AWS CLI を使っていきます。
まず、`publish-layer-version` コマンドで Lambda レイヤーを更新します。
次の手順で使用するので、`publish-layer-version` コマンド実行結果から `LayerVersionArn` をメモしておきましょう。

```bash
$ aws lambda publish-layer-version --layer-name java-basic-layer \
--zip-file fileb://build/distributions/java-layer.zip --compatible-runtimes java11
{
    "Content": {
        "Location": "https://awslambda-ap-ne-1-layers.s3.ap-northeast-1.amazonaws.com/xxxxxxxxxxxxx"
        "CodeSha256": "V9RhiYR2QpTQEq7mKcl3pQnn+TTvMVyUKL9pbTi7Gd4=",
        "CodeSize": 227065
    },
    "LayerArn": "arn:aws:lambda:ap-northeast-1:zzzzzzzzzzzzzz:layer:java-basic-layer",
    "LayerVersionArn": "arn:aws:lambda:ap-northeast-1:zzzzzzzzzzzzzz:layer:java-basic-layer:2",
    "Description": "",
    "CreatedDate": "2022-03-21T14:04:36.472+0000",
    "Version": 1,
    "CompatibleRuntimes": [
        "java11"
    ]
}
```

次に、作成した Lambda レイヤーを[サンプルの Lambda 関数](https://blog.grasswake.me/tech-posts/1647962624)へ紐付けします。
`--layers` オプションに先ほどメモした `LayerVersionArn` を指定します。

```bash
aws lambda update-function-configuration --function-name java-sample \
 --layers arn:aws:lambda:ap-northeast-1:zzzzzzzzzzzzzz:layer:java-basic-layer:2
```

### 独自ライブラリの取り込みと Lambda 関数から独自ライブラリの処理を呼び出す

まず、`libs` ディレクトリを作成し、独自ライブラリの jar ファイルをコピーします。

```bash
mkdir ~/java-sample/libs
cp ~/java-layer/build/libs/java-layer.jar ~/java-sample/libs
```

次に、[サンプルの Lambda 関数](https://blog.grasswake.me/tech-posts/1647962624)の `build.gradle` ファイルを修正します。
独自ライブラリを使用するために `dependencies` に `libs` ディレクトリないの jar ファイルを依存関係ライブラリとして定義します。

```groovy fn=java-sample/build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.code.gson:gson:2.9.0'
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
    implementation fileTree(dir: 'libs', include: '*.jar')
}

task buildZip(type: Zip) {
    from compileJava
    from processResources
}

build.dependsOn buildZip
```

最後に、[サンプルの Lambda 関数](https://blog.grasswake.me/tech-posts/1647962624)から独自ライブラリの処理を呼び出すように修正します。

```java fn=java-sample/src/main/java/sample/App.java
package sample;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;

// 独自ライブラリのインポート
import sample_lib.Util;

import java.util.Map;

public class App implements RequestHandler<Map<String, String>, String> {
  @Override
  public String handleRequest(Map<String, String> event, Context context) {
    // 独自ライブラリの処理の呼び出し
    Util.log(event, context);
    String response = new String("200 OK");
    return response;
  }
}
```

### デプロイパッケージの作成その 4

`gradle build` コマンドを実行してデプロイパッケージを作成します。

```bash
gradle build
```

`build/distributions` ディレクトリに zip 形式のデプロイパッケージが作成されます。
作成されたデプロイパッケージの中身は以下のように外部ライブラリがなくなり、クラスファイルのみになります。

```bash
$ unzip -l build/distributions/java-sample.zip
Archive:  build/distributions/java-sample.zip
  Length      Date    Time    Name
---------  ---------- -----   ----
        0  03-21-2022 23:23   sample/
     1392  03-21-2022 23:23   sample/App.class
      528  03-21-2022 23:23   previous-compilation-data.bin
---------                     -------
     1920                     3 files
```

### Lambda 関数の更新と実行その 2

作成したデプロイパッケージを使って AWS マネジメントコンソールから Lambda 関数を更新することもできますが、今回は AWS CLI を使って Lambda 関数の更新をします。

```bash
aws lambda update-function-code --function-name java-sample --zip-file fileb://build/distributions/java-sample.zip
```

Lambda 関数を実行して、エラーが出ず以下のように出力されれば成功です。
また、Lambda 関数の CloudWatch Logs のロググループに `payload` の値などが出力されているはずです。

```bash
$ aws lambda invoke --function-name java-sample  \
--payload '{"text":"Hello"}' response.txt --cli-binary-format raw-in-base64-out
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
```

## 参考情報

<https://docs.aws.amazon.com/ja_jp/lambda/latest/dg/java-handler.html>

<https://docs.aws.amazon.com/ja_jp/lambda/latest/dg/java-package.html>


Java + Gradle で Lambda レイヤー用のデプロイパッケージを作成する


## 概要

Lambda から AWS CLI コマンドを利用できるようにするため、Lambda レイヤーに AWS CLI を追加します。
本記事では、デプロイパッケージの作成方法として 2 通り紹介します。

## Lambda レイヤーに AWS CLI を追加するためのデプロイパッケージ作成方法と手順

### 方法 1: AWS CLI のインストーラーを使ってデプロイパッケージ作成する

```text fn=最終的なデプロイパッケージ( zip ファイルアーカイブ)のフォルダ構成
.
└── bin
    ├── aws
    └── 省略(色々入ります)
```

#### 作業用ディレクトリとレイヤーパスの作成

```bash
mkdir ~/aws_cli_layer
cd ~/aws_cli_layer
mkdir aws-cli aws-bin bin
```

#### AWS CLI インストーラのダウンロードとインストール

`bin` ディレクトリに AWS CLI のバイナリーファイルなどを追加します。

```bash
cd ~/aws_cli_layer

# wget もしくは curl いづれかのコマンドで AWS CLI のインストールファイルをダウンロードします。
wget https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip
curl -O https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip

# ファイルを解凍します。
unzip awscli-exe-linux-x86_64.zip

# 作業用ディレクトリにインストールします。
./aws/install -i ~/aws_cli_layer/aws-cli -b ~/aws_cli_layer/aws-bin

# aws コマンドのバイナリーファイルなどが入ったディレクトリの中身を全てコピーします。
cp -r ./aws-cli/v2/current/dist/* ./bin
```

#### デプロイパッケージ化 ( zip ファイルアーカイブ )

```bash
cd ~/aws_cli_layer
zip -r9 aws_cli_layer.zip bin
```

### 方法 2: aws-lambda-layer-awscli リポジトリを使ってデプロイパッケージ作成する

以下の `aws-lambda-layer-awscli` という AWS 公式のリポジトリに AWS CLI を含めた Lambda レイヤーを作成するためのブランチがあります。
`aws` コマンドだけでなく、`jq` コマンドなども含まれています。

<https://github.com/aws-samples/aws-lambda-layer-awscli>

#### aws-lambda-layer-awscli リポジトリのクローンとデプロイパッケージ作成 ( zip ファイルアーカイブ )

```bash
# aws-lambda-layer-awscli リポジトリのクローンします。
git clone https://github.com/aws-samples/aws-lambda-layer-awscli.git
cd aws-lambda-layer-awscli

# ブランチを awscli-v2-python37 に切り替えます。
git checkout awscli-v2-python37

# ビルドの実行をします。
# ビルドが完了すると、カレントディレクトリに layer.zip が作成されます。これがデプロイパッケージとなります。
make
```

## Lambda レイヤーの作成

デプロイパッケージを使用した Lambda レイヤーの作成手順はこちらにまとめてあります。

<https://blog.grasswake.me/tech-posts/1640005577>

## 動作確認

作成した Lambda レイヤーを使用する Lambda 関数を作成し、テスト実行してみます。
使用するカスタムランタイムはなんでもいいですが、本記事ではカスタムランタイムである Amazon Linux 2 を使用します。
特にエラーが発生せず、実行結果のログに AWS CLI のバージョンの表示と、指定した S3 バケットにファイルが転送されていれば成功です。

:::warning

方法 1 で作成した Lambda レイヤーは Lambda の全てランタイムがサポートするディレクトリ構造のため、パスを指定しなくても aws コマンドが実行できます。
しかし、方法 2 で作成した Lambda レイヤーは Lambda のランタイムがサポートするディレクトリ構造で作成されていないため、aws コマンドの実行にはパスを含める必要があります。

:::

```hello.sh fn=方法 1 で作成した Lambda レイヤーの場合
function handler () {
    EVENT_DATA=$1
    aws --version
    aws s3 cp ./bootstrap s3://xxxxxxxxxxxxxx
    RESPONSE="{\"statusCode\": 200, \"body\": \"Hello from Lambda!\"}"
    echo $RESPONSE
}
```

```hello.sh fn=方法 2 で作成した Lambda レイヤーの場合
function handler () {
    EVENT_DATA=$1
    /opt/awscli/aws --version
    /opt/awscli/aws s3 cp ./bootstrap s3://xxxxxxxxxxxxxx
    RESPONSE="{\"statusCode\": 200, \"body\": \"Hello from Lambda!\"}"
    echo $RESPONSE
}
```

![実行結果](/images/posts/tech-posts/1641911694/test_result.png)

## 参考文献

<https://docs.aws.amazon.com/ja_jp/cli/latest/userguide/install-cliv2-linux.html>

<https://docs.aws.amazon.com/ja_jp/lambda/latest/dg/configuration-layers.html>


Lambda レイヤーにライブラリを追加する ( AWS CLI 編)


## 概要

Lambda の Python ランタイムから URLExtract モジュールを利用できるようにするため、Lambda レイヤーに URLExtract を追加します。

## Lambda レイヤーに URLExtract モジュールを追加する手順

### 作業用ディレクトリとレイヤーパスの作成

```bash
mkdir -p ~/urlextract_layer/python
```

### urlextract インストール

`python` ディレクトリに `urlextract` をインストールします。

```bash
cd ~/urlextract_layer
pip install urlextract -t python
```

### デプロイパッケージ化( zip ファイルアーカイブ)

```bash
cd ~/urlextract_layer
zip -r9 urlextract_layer.zip python
```

### Lambda レイヤーの作成

デプロイパッケージを使用した Lambda レイヤーの作成手順はこちらにまとめてあります。

<https://blog.grasswake.me/tech-posts/1640005577>

### Read-only file system: '/home/sbx_user1051'

:::warning

URLExtract は書き込み可能なキャッシュディレクトリーを必要とします。
利用するキャッシュディレクトリーは URLExtract インスタンスの初期化時に `cache_dir` パラメータで指定することができます。

一方で、Lambda の環境では書き込み可能なディスク領域は、`/tmp` ディレクトリ内のみとなっています。
そのため、そのまま URLExtract を利用すると、ホームディレクトリ( `/home/sbx_user1051` ) に書き込もうとして、`Read-only file system: '/home/sbx_user1051'` エラーが発生します。

解決方法としては、利用するキャッシュディレクトリーとして `/tmp` ディレクトリを使用するようにすることで回避できます。

:::

```py
import json
from urlextract import URLExtract

def lambda_handler(event, context):
    extractor = URLExtract(cache_dir='/tmp')
```


Lambda レイヤーにライブラリを追加する ( URLExtract 編)


## 概要

Lambda から Terraform コマンドを利用できるようにするため、Lambda レイヤーに Terraform を追加します。

## Lambda レイヤーに Terraform を追加する手順

```text fn=最終的なデプロイパッケージ( zip ファイルアーカイブ)のフォルダ構成
.
└── bin
    └── terraform
```

### 作業用ディレクトリとレイヤーパスの作成

```bash
mkdir -p ~/terraform_layer/bin
```

### Terraform のダウンロード

`bin` ディレクトリに Terraform のバイナリーファイルを追加します。

```bash
cd ~/terraform_layer/bin

# wget もしくは curl いづれかのコマンドで Terraform のバイナリーファイルをダウンロードします。
# Lamda レイヤーを使用する Lambda 関数の アーキテクチャが x86_64 の場合は以下の URL からダウンロードします。
wget https://releases.hashicorp.com/terraform/1.1.2/terraform_1.1.2_linux_amd64.zip
curl -O https://releases.hashicorp.com/terraform/1.1.2/terraform_1.1.2_linux_amd64.zip

# Lamda レイヤーを使用する Lambda 関数の アーキテクチャが arm64 の場合は以下の URL からダウンロードします。
wget https://releases.hashicorp.com/terraform/1.1.2/terraform_1.1.2_linux_arm64.zip
curl -O https://releases.hashicorp.com/terraform/1.1.2/terraform_1.1.2_linux_arm64.zip

# ファイルを解凍します。
unzip terraform_1.1.2_linux_amd64.zip

# 実行権限を付与しておきます。
chmod 755 terraform
```

### デプロイパッケージ化( zip ファイルアーカイブ)

```bash
cd ~/terraform_layer
zip -r9 terraform_layer.zip bin
```

### Lambda レイヤーの作成

デプロイパッケージを使用した Lambda レイヤーの作成手順はこちらにまとめてあります。

<https://blog.grasswake.me/tech-posts/1640005577>

## 動作確認

作成した Lambda レイヤーを使用する Lambda 関数を作成し、テスト実行してみます。
使用するカスタムランタイムはなんでもいいですが、本記事ではカスタムランタイムである Amazon Linux 2 を使用します。
特にエラーが発生せず、実行結果のログに terraform のバージョンが表示されていれば成功です。

```hello.sh
function handler () {
    EVENT_DATA=$1
    terraform --version
    RESPONSE="{\"statusCode\": 200, \"body\": \"Hello from Lambda!\"}"
    echo $RESPONSE
}
```


Lambda レイヤーにライブラリを追加する ( Terraform 編)


## 概要

Lambda レイヤーのデプロイパッケージの作成後の基本的な Lambda レイヤーの作成手順をまとめました。
サンプルとしてこちらの記事で作成した Lambda レイヤーを使用します。

<https://blog.grasswake.me/tech-posts/1639995611>

## Lamda レイヤーについて

[Lambda レイヤーの作成と共有 \- AWS Lambda](https://docs.aws.amazon.com/ja_jp/lambda/latest/dg/configuration-layers.html#configuration-layers-path)

> ライブラリの依存関係をレイヤーに含める
> Lambda ランタイムごとに、PATH 変数に /opt ディレクトリ内の特定のフォルダが含まれます。レイヤー .zip ファイルアーカイブに同じフォルダ構造を定義すると、関数コードはパスを指定しなくても、レイヤーコンテンツにアクセスできます。

上記の記述のように、Lambda レイヤーにアップロードする zip ファイルアーカイブに特定のディレクトリにライブラリなどの依存関係を含めておくだけで、パスを指定しなくてもそれを利用することができます。
Lambda レイヤーを使用すると、他の Lambda 関数とのコードの共有と責任の分離ができます。
個人的には、ちょっとでもデプロイパッケージが大きいと、Lmabda のコンソールでコードを修正できなくなるので、外部ライブラリを使用する時点で他の Lambda 関数と共有する・しない関係なく Lambda レイヤー化しています。

## Lambda レイヤーの作成手順 ( AWS マネジメントコンソール編 )

### Lambda レイヤーの作成

Lambda コンソールのナビゲーションから「レイヤー」を選択して、「レイヤー」ページを開き、「レイヤーの作成」を選択します。

![Lambdaコンソール](/images/posts/tech-posts/1640005577/layer_page.png)

Lambda レイヤーの `名前`と「互換性のあるランタイム - オプション」を入力、「デプロイパッケージ」のアップロードを行います。
「互換性のあるランタイム - オプション」は複数選択可能で、この Lambda レイヤーを利用する予定の Lambda 関数のランタイムを選択します。ここで選択したランタイムを使用している Lambda 関数に対して、Lambda レイヤーを追加することができます。
デプロイパッケージ ( .zip ファイル ) をアップロードします。

:::info
画面に明記されているように、デプロイパッケージ ( .zip ファイル ) のサイズが 10 MB を超える場合は、Amazon S3 経由でアップロードするのを推奨しているようです。
:::

:::warning
Lambda 関数に指定可能なカスタムランタイムは、2021/12/20 時点では「Amazon Linux 1」と「Amazon Linux 2」の 2 種類が選択できます。
しかし、2021/12/20 時点では AWS マネジメントコンソールを使用して、Lambda レイヤーを作成する際に、「互換性のあるランタイム - オプション」で「カスタムランタイム」という選択肢しかありませんでした。
この「カスタムランタイム」とは「Amazon Linux 1」を指しており、「Amazon Linux 2」は選択できませんでした。
一方で、AWS CLI で Lambda レイヤーを作成する際は、「Amazon Linux 2」を選択可能です。
そのため、ランタイム環境が「Amazon Linux 2」の Lambda 関数で使用する Lambda レイヤーを使用したい場合は、AWS CLI で Lambda レイヤーを作成してください。
:::

![Lambdaレイヤー作成](/images/posts/tech-posts/1640005577/layer_zip.png)

Amazon S3 を使用したアップロードを行う場合は、Amazon S3 に アップロードしたデプロイパッケージ ( .zip ファイル ) のオブジェクト URL を入力します。

![S3の場合](/images/posts/tech-posts/1640005577/layer_s3.png)

### Lambda 関数に Lambda レイヤーを追加

対象の Lambda 関数のコンソールの「コード」タブを選択し、「レイヤーの追加」を選択します。

![レイヤーの追加](/images/posts/tech-posts/1640005577/layer_add_start.png)

「レイヤーソース」としてカスタムレイヤーを選択し、追加する Lambda レイヤーとバージョンを選択し、「追加」を選択します。

![レイヤーの追加中](/images/posts/tech-posts/1640005577/layer_adding.png)

追加が完了です。

![レイヤー追加完了](/images/posts/tech-posts/1640005577/layer_add_comp.png)

## Lambda レイヤーの作成手順 ( AWS CLI 編 )

### Lambda レイヤーの作成・更新

Lambda レイヤーを作成または更新する場合は、`publish-layer-version` コマンドを使用します。

:::info
ランタイム環境「Amazon Linux 2」を対象とした Lambda レイヤーを作成したい場合は、`--compatible-runtimes` オプションで `provided.al2` を指定してください。
:::

なお、デプロイパッケージ (.zip ファイルアーカイブ) のサイズ上限は 50 MB です。
デプロイパッケージ (.zip ファイルアーカイブ) が 50 MB 以下であれば、`publish-layer-version` コマンドで直接アップロードできます。
50 MB を超える場合は、一旦 S3 にアップロードして、格納した場所を `publish-layer-version` コマンドで指定します。

```bash fn=直接アップロードする場合
aws lambda publish-layer-version --layer-name jq_layer \
  --zip-file fileb://jq_layer.zip \
  --compatible-runtimes provided
```

```bash fn=S3 経由の場合
aws s3 cp jq_layer.zip s3://<バケット名>
aws lambda publish-layer-version --layer-name jq_layer \
  --content S3Bucket=<バケット名>,S3Key=jq_layer.zip \
  --compatible-runtimes provided
```

### Lambda 関数を新規に作成する際に Lambda レイヤーを追加する

Lambda 関数を作成する `create-function` コマンドの `--layer` オプションに追加したい Lambda レイヤーの ARN を指定します。

```bash fn=直接アップロードする場合
aws lambda create-function --function-name sample_function \
  --handler function.handler \
  --runtime provided \
  --role arn:aws:iam::xxxxxxxxxxxxxxxxxx:role/lambda-role \
  --zip-file fileb://function.zip \
  --layers arn:aws:lambda:ap-northeast-1:xxxxxxxxxxxxxxxxxx::layer:jq_layer:1
```

```bash fn=S3 経由の場合
aws s3 cp jq_layer.zip s3://<バケット名>
aws lambda create-function --function-name sample_function \
  --handler function.handler \
  --runtime provided \
  --role arn:aws:iam::xxxxxxxxxxxxxxxxxx:role/lambda-role \
  --content S3Bucket=<バケット名>,S3Key=jq_layer.zip \
  --layers arn:aws:lambda:ap-northeast-1:xxxxxxxxxxxxxxxxxx::layer:jq_layer:1
```

### 作成済みの Lmabda 関数に Lambda レイヤーを追加する

作成済みの Lambda 関数の設定を更新する `update-function-configuration` コマンドの `--layer` オプションに追加したい Lambda レイヤーの ARN を指定します。

```bash
aws lambda update-function-configuration --function-name sample_function-runtime \
  --layers arn:aws:lambda:ap-northeast-1:xxxxxxxxxxxxxxxxxx::layer:jq_layer:1
```

### Lambda 関数を直接実行する

```bash
aws lambda invoke --function-name bash-runtime --payload '{"text":"Hello"}' response.txt
```


Lambda レイヤーの作成手順


## 概要

Lambda から jq コマンドを利用できるようにするため、Lambda レイヤーに jq を追加します。

## Lambda レイヤーに jq を追加する手順

```text fn=最終的なデプロイパッケージ( zip ファイルアーカイブ)のフォルダ構成
.
└── bin
    └──jq
```

### 作業用ディレクトリとレイヤーパスの作成

```bash
mkdir -p ~/jq_layer/bin
```

### jq のダウンロード

bin ディレクトリに jq のバイナリーファイルを追加します。

```bash
cd ~/jq_layer/bin

# 以下の wget もしくは curl いづれかのコマンドで jq のバイナリーファイルをダウンロードします。
wget https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64  -O jq
curl -Lo jq https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64

# 実行権限を付与しておきます。
chmod 755 jq
```

### デプロイパッケージ化( zip ファイルアーカイブ)

```bash
cd ~/jq_layer
zip -r9 jq_layer.zip bin
```

### Lambda レイヤーの作成

デプロイパッケージを使用した Lambda レイヤーの作成手順はこちらにまとめてあります。

<https://blog.grasswake.me/tech-posts/1640005577>

## 動作確認

作成した Lambda レイヤーを使用する Lambda 関数を作成し、テスト実行してみます。
使用するカスタムランタイムはなんでもいいですが、本記事ではカスタムランタイムである Amazon Linux 2 を使用します。
特にエラーが発生せず、実行結果のログに jq のバージョンが表示されていれば成功です。

```hello.sh
function handler () {
    EVENT_DATA=$1
    jq --version
    RESPONSE="{\"statusCode\": 200, \"body\": \"Hello from Lambda!\"}"
    echo $RESPONSE
}
```


Lambda レイヤーにライブラリを追加する ( jq 編)


AWS Lambda から cx_Oracle という Python モジュールを使用して RDS(OracleDB) へ接続してみたので、その手順をまとめました。

## Lambda から Python で RDS (OracleDB) へ接続する (cx_Oracle 編)

Lambda 関数から `cx_Oracle` を利用するための Lambda レイヤーを作成します。
`cx_Oracle` のドキュメントでは以下のように記載しています。

[Introduction to cx_Oracle — cx_Oracle 8\.3\.0 documentation](https://cx-oracle.readthedocs.io/en/latest/user_guide/introduction.html)

> Python programs call cx_Oracle functions. Internally cx_Oracle dynamically loads Oracle Client libraries to access OracleDB.
> ...
> On Linux, the libaio (sometimes called libaio1) package is needed.

上記の記述のように、`cx_Oracle` は内部的に `Oracle Client libraries` を動的にロードして、Oracle データベースにアクセスまた、`libaio(libaio1)` パッケージも必要です。
そのため、Lambda レイヤーには `cx_Oracle` と `Oracle Client libraries` と `libaio(libaio1)` を含める必要があります。

## Lambda から Python で RDS (OracleDB) へ cx_Oracle を使って接続する手順

### 前提条件

- 動作確認環境
  - Lambda Runtime: Python3.7, Python3.8, Python3.9
  - RDS(OracleDB): Oracle 19.0.0.0.ru-2021-07.rur-2021-07.r1
- 作業環境
  - EC2 (Amazon Linux2)
    - Python 3.7 と `libaio1` がすでにインストールされているためお勧めです。
- cx_Oracle 8.3
- Oracle Client libraries 19.13

### 作業ディレクトリの作成

```bash fn=~
mkdir ~/oracle_layer
cd ~/oracle_layer
mkdir python/ lib/
```

### cx_Oracle モジュールのインストール

pip コマンドに -t オプションを指定して python ディレクトリに `cx_Oracle` モジュールをインストールします。

```bash fn=~/oracle_layer
pip install cx_Oracle -t python/
```

### Oracle Client libraries のインストール

Oracle Client libraries をダウンロードして lib ディレクトリに展開します。
Oracle Client libraries は[ここから](https://www.oracle.com/jp/database/technologies/instant-client/linux-x86-64-downloads.html)ダウンロードします。

```bash fn=~/oracle_layer
wget https://download.oracle.com/otn_software/linux/instantclient/1913000/instantclient-basic-linux.x64-19.13.0.0.0dbru.zip -O oracle_client_lib.zip
unzip -j oracle_client_lib.zip -d lib/
```

### libaio1 を lib ディレクトリにコピーする

```bash fn=~/oracle_layer
cp /lib64/libaio.so.1 lib/libaio.so.1
```

### デプロイパッケージを作成する

```bash fn=~/oracle_layer
zip -r -y layer.zip python/ lib/
```

:::warning
lib ディレクトリ内の Oracle Client libraries は一部のファイルがシンボリックリンクです。
シンボリックリンクのまま格納する必要があるため、-y オプションを忘れずに。
-y オプションの替わりに --symlinks オプションでもいいです。
:::

### Lambda レイヤーの作成

#### Lambda レイヤーの作成パターンその 1: デプロイパッケージを S3 にアップロードしてそれを使用する

```bash fn=~/oracle_layer
aws s3 cp oracle_layer.zip s3://lambda_layer/oracle_layer.zip
aws lambda publish-layer-version \
    --layer-name cx_Oracle \
    --description "cx_Oracle layer" \
    --content S3Bucket=lambda_layer,S3Key=oracle_layer.zip \
    --compatible-runtimes python3.7 python3.8 python3.9
```

#### Lambda レイヤーの作成パターンその 2: ローカルにあるデプロイパッケージを使用する

```bash fn=~/oracle_layer
aws lambda publish-layer-version \
    --layer-name cx_Oracle \
    --description "cx_Oracle layer" \
    --zip-file fileb://oracle_layer.zip \
    --compatible-runtimes python3.7 python3.8 python3.9
```

### 接続確認

作成した Lambda レイヤーを使用する Lambda 関数を作成し、テスト実行して接続確認してみます。
特にエラーが発生しなければ成功です。

```py
import cx_Oracle

def lambda_handler(event, context):
    connection = cx_Oracle.connect(<username>, <password>, <hostname>)
```

## 参考文献

<https://cx-oracle.readthedocs.io/en/latest/user_guide/introduction.html>

<https://docs.aws.amazon.com/ja_jp/lambda/latest/dg/configuration-layers.html>


Lambda レイヤーの記事一覧