
## 概要

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 編)


Terraform で Vue.js や Rect などで作られた SPA サイトを独自ドメインで HTTPS 配信するためのインフラを構築していきます。
サンプルソースをリポジトリにまとめてみたのでこれを参考に紹介していきます。

:::info

- terafform のバージョンを 1.0.11 から 1.1.6 に変更
- aws provider のバージョンを 3.68.0 から 4.2.0 に変更
- aws provider のバージョンが 3.68.0 の場合のソースはサンプルリポジトリにて [tag(aws-provider-3.68.0)](https://github.com/grasswake/terraform_aws_static_site/tree/aws-provider-3.68.0) 付けしてるのでそちらを参照してください。

:::

## サンプルリポジトリ

サンプルとなるソースをリポジトリにまとめてみたのでこれを参考に紹介していきます。

<https://github.com/grasswake/terraform_aws_static_site>

※本記事の内容と基本的に一緒ですが、一気に作るのでなく Route53 と ACM、CloudFront の３ディレクトリに分けてます。
その為 remote state を使用した構成になっています。因みに リソース名の定義が下手だったり、access_key などの扱いが雑ですので使ってみる場合は使いやすい形に直してください。

## 前提

- 独自ドメインでのアクセスを行うために、お名前.com などでドメインを購入してください。
  - この記事ではお名前.com で `example.com` というドメインを購入していると想定でいます
- アクセス URL は `example.com` になります。`www.example.com` でのアクセスは想定していません。

## Terraform

### Terraform の Provider 定義

基本的には `region` は `ap-northeast-1` ですが、一部のリソース(ACM, CloudFunctions)の作成は `us-east-1` で行うので、以下のように定義している想定です。

```hcl
provider "aws" {
  access_key = var.aws_access_key
  secret_key = var.aws_secret_key
  region     = var.region
}

provider "aws" {
  alias      = "us_east"
  access_key = var.aws_access_key
  secret_key = var.aws_secret_key
  region     = "us-east-1"
}
```

## Route53 に Terraform で ホストゾーンを作成

まず Route53 でホストゾーンを作成します。
作成するホストゾーン名はパラメータで指定します。

```hcl
resource "aws_route53_zone" "main" {
  name = var.zone_name
}
```

`terraform apply` を実行し、AWS マネジメントコンソールなどでホストゾーンが作成されていることと、NS レコードが作成されていることを確認しましょう。
もし、ドメインを Route53 で購入または Route 53 に移管していないようであれば、この NS レコードをお名前.com などのドメインを購入したところで、Route53 に追加された NS レコードの値を使い、そのドメインに対する NS(ネームサーバー)の変更をしましょう。

## Terraform で ACM による SSL 証明書を発行

Route53 へのホストゾーンの作成と必要であれば NS 変更が終わったら、ACM で SSL 証明書を発行します。

```hcl
resource "aws_acm_certificate" "main_cert" {
  provider                  = aws.us_east
  domain_name               = data.terraform_remote_state.route53.outputs.main_zone_name
  # wwwありのドメインも対象にしたい場合は以下を追加、使用予定はないけどリダイレクトしやすい環境に移行などした時のことを考え一応入れとく
  subject_alternative_names = ["www.${data.terraform_remote_state.route53.outputs.main_zone_name}"]
  # DNSを使ったドメイン認証
  validation_method         = "DNS"
}

# DNSを使ったドメイン認証のためにRoute53にcnameレコードを作成
resource "aws_route53_record" "main_cnames" {
  for_each = {
    for dvo in aws_acm_certificate.main_cert.domain_validation_options : dvo.domain_name => {
      name   = dvo.resource_record_name
      record = dvo.resource_record_value
      type   = dvo.resource_record_type
    }
  }
  zone_id = data.terraform_remote_state.route53.outputs.main_zone_id
  name    = each.value.name
  records = [each.value.record]
  type    = each.value.type
  ttl     = 60
}

resource "aws_acm_certificate_validation" "main_cert_validation" {
  provider                = aws.us_east
  certificate_arn         = aws_acm_certificate.main_cert.arn
  validation_record_fqdns = [for record in aws_route53_record.main_cnames : record.fqdn]
}
```

## Terraform で CloudFront と OAI と S3 　を作成

ここから一気に色々作成していきます。

### Terraform で S3 を作成

```hcl
# vueなど配信コンテンツ用のバケット
resource "aws_s3_bucket" "origin_bucket" {
  bucket = local.domain_name
  force_destroy = true
}

#  CloudFront 以外からアクセスできる必要はないので、ACL をプライベートにします
resource "aws_s3_bucket_acl" "origin_bucket_acl" {
  bucket = aws_s3_bucket.origin_bucket.id
  acl    = "private"
}

# CloudFront 以外からアクセスできる必要はないので、パブリックアクセスを全てオフにします
resource "aws_s3_bucket_public_access_block" "origin_bucket" {
  bucket                  = aws_s3_bucket.origin_bucket.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

# CloudFrontのアクセスログ用のバケット
resource "aws_s3_bucket" "logging_bucket" {
  bucket = "cloudfront-logs.${local.domain_name}"
  force_destroy = true
}

# パブリックアクセスを全てオフにします
resource "aws_s3_bucket_public_access_block" "logging_bucket" {
  bucket                  = aws_s3_bucket.logging_bucket.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

# ログのバケットのライフサイクルを設定します
# この辺はお好みで変更してください
resource "aws_s3_bucket_lifecycle_configuration" "logging_bucket_lifecycle_config" {
  bucket = aws_s3_bucket.logging_bucket.bucket

  rule {
    id      = "s3-cloudfront-logs-transitions"
    status = "Enabled"

    expiration {
      days = 365
    }

    transition {
      days          = 90
      storage_class = "STANDARD_IA"
    }

    transition {
      days          = 180
      storage_class = "GLACIER"
    }
  }
}
```

### Terraform で OAI (Origin Access Identity)　を作成

パブリックアクセスでない S3 に CloudFront がアクセスできるようにするために、OAI を作成します

```hcl
# OAIの作成
resource "aws_cloudfront_origin_access_identity" "oai" {
  comment = "access-identity-ap-northeast-1-cloudfront-resource-periosprint-dev"
}

data "aws_iam_policy_document" "origin_access_identity_policy" {
  statement {
    sid       = "OriginAccessIdentity"
    actions   = ["s3:GetObject"]
    resources = ["${aws_s3_bucket.origin_bucket.arn}/*"]

    principals {
      type        = "AWS"
      identifiers = [aws_cloudfront_origin_access_identity.oai.iam_arn]
    }
  }
}

# OAIを利用したCloudFrontからのアクセスを許可するポリシーをS3のバケットに設定
resource "aws_s3_bucket_policy" "origin_bucket_policy" {
  bucket = aws_s3_bucket.origin_bucket.id
  policy = data.aws_iam_policy_document.origin_access_identity_policy.json
}
```

### Terraform で CloudFront を作成

```hcl
# キャッシュポリシーの作成
resource "aws_cloudfront_cache_policy" "this" {
  name        = local.uppercase_domain_name
  comment     = local.uppercase_domain_name
  # default_ttl と max_ttl min_ttl は開発環境なら0にしてキャッシュしない方が開発しやすいです
  default_ttl = 86400
  max_ttl     = 31536000
  min_ttl     = 1
  parameters_in_cache_key_and_forwarded_to_origin {
    cookies_config {
      cookie_behavior = "none"
    }
    headers_config {
      header_behavior = "none"
    }
    query_strings_config {
      query_string_behavior = "none"
    }
    enable_accept_encoding_brotli = true
    enable_accept_encoding_gzip = true
  }
}

# オリジンリクエストポリシーの作成
resource "aws_cloudfront_origin_request_policy" "this" {
  name    = local.uppercase_domain_name
  comment = local.uppercase_domain_name
  cookies_config {
    cookie_behavior = "none"
  }
  headers_config {
    header_behavior = "none"
  }
  query_strings_config {
    query_string_behavior = "none"
  }
}

resource "aws_cloudfront_distribution" "cfd" {
  aliases = [local.domain_name]

  comment             = local.domain_name
  enabled             = true
  is_ipv6_enabled     = true
  price_class         = "PriceClass_200"
  default_root_object = "index.html"

  origin {
    domain_name = aws_s3_bucket.origin_bucket.bucket_regional_domain_name
    origin_id   = local.domain_name

    s3_origin_config {
      origin_access_identity = aws_cloudfront_origin_access_identity.oai.cloudfront_access_identity_path
    }
  }

  logging_config {
    include_cookies = false
    bucket          = aws_s3_bucket.logging_bucket.bucket_domain_name
  }

  default_cache_behavior {
    allowed_methods  = ["GET", "HEAD"]
    cached_methods   = ["GET", "HEAD"]
    target_origin_id = local.domain_name
    # httpでアクセスされた場合、httpsにリダイレクト
    viewer_protocol_policy = "redirect-to-https"
    compress               = true
    cache_policy_id = aws_cloudfront_cache_policy.this.id
    origin_request_policy_id = aws_cloudfront_origin_request_policy.this.id
  }

  custom_error_response {
    error_caching_min_ttl = "300"
    error_code            = "403"
    response_code         = "200"
    # Nuxt や Next.js で SSG を用いていて 404.html など専用ページがあれば置き換えてください。
    response_page_path    = "/index.html"
  }

  custom_error_response {
    error_caching_min_ttl = "300"
    error_code            = "404"
    response_code         = "200"
    # Nuxt や Next.js で SSG を用いていて 404.html など専用ページがあれば置き換えてください。
    response_page_path    = "/index.html"
  }

  restrictions {
    geo_restriction {
      restriction_type = "none"
    }
  }

  viewer_certificate {
    acm_certificate_arn      = data.terraform_remote_state.acm.outputs.acm_main_cert_arn
    ssl_support_method       = "sni-only"
    minimum_protocol_version = "TLSv1.2_2019"
  }
}

```

### Terraform で Route53 (A レコード) を作成

Route53 に A レコードを追加して、独自ドメインにアクセスされた場合、CloudFront にアクセスされるようにします

```hcl
resource "aws_route53_record" "www" {
  zone_id = local.zone_id
  name    = local.domain_name
  type    = "A"

  alias {
    name                   = aws_cloudfront_distribution.cfd.domain_name
    zone_id                = aws_cloudfront_distribution.cfd.hosted_zone_id
    evaluate_target_health = false
  }
}
```

## おまけ (Basic 認証と URL の書き換え）

開発環境などアクセスされたくない場合に便利

### Terraform で CloudFront Functions (Basic 認証用の処理) を作成

```js fn=basic_auth/function.js
function handler(event) {
  var request = event.request
  var uri = request.uri
  var headers = request.headers

  // Basic 認証に用いる文字列(dXNlcjpwYXNzd29yZA==)の部分は shell などで以下のコマンドで生成します。
  // echo -n user:password | base64
  var basicAuth = 'Basic dXNlcjpwYXNzd29yZA=='

  if (
    typeof headers.authorization === 'undefined' ||
    headers.authorization.value !== basicAuth
  ) {
    return {
      statusCode: 401,
      statusDescription: 'Unauthorized',
      headers: { 'www-authenticate': { value: 'Basic' } },
    }
  }

  if (uri === '/') {
    return request
  }

  if (uri.endsWith('/')) {
    // リクエスト URL が https://hogehoge.com/foo/ の様に "/" で終わる場合は、この分岐に入ります。
    // その際の扱いは要件によって変えてください。

    // パターン1: Nuxt の例ですが、pages/bar/index.vue のような構成の場合は、
    // リクエスト URL が https://hogehoge.com/bar/ であれば、
    // https://hogehoge.com/bar/index.html にルーティングして欲しいので request.uri の末尾に index.html を付与します。
    request.uri = request.uri.concat('index.html')
    return request

    // パターン2: "/" で終わる場合は "/" を削ってリダイレクト
    return {
      statusCode: 302,
      statusDescription: 'Found',
      headers: {
        location: {
          value: request.uri.slice(0, -1),
        },
      },
    }
  } else if (!uri.includes('.')) {
    // ファイル名に "." が含まれていない = 拡張子がない場合、request.uri の末尾に  ".html" をつける
    request.uri = request.uri.concat('.html')
  }

  return request
}
```

### Terraform で CloudFront Functions を CloudFront に設定

```hcl
resource "aws_cloudfront_function" "basic_auth" {
  name    = "basic_auth"
  runtime = "cloudfront-js-1.0"
  comment = "basic_auth function"
  publish = true
  code    = file("${path.module}/basic_auth/function.js")
}

resource "aws_cloudfront_distribution" "cfd" {
  default_cache_behavior {
    function_association {
      event_type = "viewer-request"
      function_arn = aws_cloudfront_function.basic_auth.arn
    }
  }
}
```


Terraform で SPA を配信する HTTPS 静的サイトのインフラを構築する[Route53 + ACM + CloudFront + S3 + CloudFront Functions(Basic 認証 + α)]


Terraform コマンド実行時に、AssumeRole でデプロイに必要な権限をもつ IAM ロールにスイッチロールして `Terraform init`から`Terraform deploy/apply/destroy`までを実行してみた

## 背景

- Terraform でデプロイするユーザのアクセスキーが万が一漏れても被害が最小限になるようにしたい
- 一々 AWS Cli で AssumeRole コマンド実行してアクセスキーを切り替える（上書きする）のがめんどくさいのでそうしなくていいようにしたい
- 誰がリソースをいじったかわかるようにしたい

## 流れ

- `terraform init` 実行時
  - IAM ユーザー → S3 用 IAM ロールにスイッチ
- `terraform plan/deploy/destroy` 実行時
  - IAM ユーザー → S3 用 IAM ロールにスイッチ → デプロイ用 IAM ロールにスイッチ

## IAM ユーザー・ロール・ポリシーの作成

下記を作成していきます

IAM ユーザーは社員毎に用意されているものとします

| AWS アカウント(アカウント ID) | IAM          | 名前                                    | 役割                                                     |
| ----------------------------- | ------------ | --------------------------------------- | -------------------------------------------------------- |
| Employee(111111111111)        | IAM ユーザー | sample                                  | IAM ユーザ (AssumeRole しかできない ユーザー が望ましい) |
| Employee(111111111111)        | IAM ポリシー | sample-service-assume-policy            | IAM ユーザに AssumeRole 権限を持つ                       |
| ServiceA(999999999999)        | IAM ポリシー | sample-service-terraform-backend-policy | S3 に対する権限を持つ                                    |
| ServiceA(999999999999)        | IAM ロール   | sample-service-terraform-backend-role   | S3 に対する権限を持つ                                    |
| ServiceA(999999999999)        | IAM ロール   | sample-service-terraform-deploy-role    | AWS の各サービスに対する権限を持つ                       |

## Terraform の backend ( S3 ) 用の IAM ポリシーと IAM ロールの作成

`sample-service-terraform-backend-policy` を作成します。

この IAM ポリシーは Terraform が使用する state ファイルを管理する先として S3 を利用するための権限を与えるためのものになります。
その為、以下のようなポリシーを定義します。

- S3 オブジェクトの読み込みと書き込み権限
- `Resource` に state ファイルを管理する S3 バケットを指定

```json fn=ポリシー
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "VisualEditor0",
      "Effect": "Allow",
      "Action": ["s3:PutObject", "s3:GetObject", "s3:ListBucket"],
      "Resource": [
        "arn:aws:s3:::sample-service-terraform-tfstate/*",
        "arn:aws:s3:::sample-service-terraform-tfstate"
      ]
    }
  ]
}
```

`sample-service-terraform-backend-role` を作成します。

この IAM ロールは `sample-service-terraform-backend-policy` がアタッチされます。
Terraform には Backend 周りはこのロールに AssumeRole してもらい処理を行ってもらいます。

以下のように IAM ロールを定義します。

- `sample-service-terraform-backend-policy` をアタッチします
- 信頼する相手として「対象となる IAM ユーザの AWS アカウント」を指定します
- よりセキュリティを強くするため条件を指定します
  - `sts:RoleSessionName` で `SessionName` として実行する IAM ユーザーの名前を指定するようにします
  - `sts:ExternalId` (外部 ID) を指定します

```json fn=信頼関係
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::111111111111:root"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "sts:RoleSessionName": "${aws:username}",
          "sts:ExternalId": "sample-service-backend"
        }
      }
    }
  ]
}
```

## AssumeRole によるスイッチロール先であるデプロイ用の IAM ロールの作成

`sample-service-terraform-backend-role` を作成します。

この IAM ロールは Terraform にデプロイ時に AWS の各サービスに対する権限を与えるためのものになります。
Terraform には Deploy 周りはこのロールに AssumeRole してもらい処理を行ってもらいます。

以下のように Role を定義します。

- 付与するアクセス権限を必要に応じて付与してください
- 信頼する相手として `sample-service-terraform-backend-role` を指定します
  - こうすることで `sample-service-terraform-backend-role` にスイッチしてる IAM ユーザーのみがスイッチできます
- よりセキュリティを強くするため条件を指定します
  - `sts:ExternalId` (外部 ID) を指定します

```json fn=信頼関係
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::999999999999:role/sample-service-terraform-backend-role"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "sts:ExternalId": "sample-service-deploy"
        }
      }
    }
  ]
}
```

## IAM ユーザーに AssumeRole でデプロイ用の IAM ロールにスイッチロールできるようにする

`sample-service-assume-policy` を作成します。

この IAM ポリシーは `sample-service-terraform-backend-role` に Assume Role できるようにする為のものです。
その為、以下のようなポリシーを定義します。

```json fn=ポリシー
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "VisualEditor0",
      "Effect": "Allow",
      "Action": "sts:AssumeRole",
      "Resource": [
        "arn:aws:iam::999999999999:role/sample-service-terraform-backend-role"
      ]
    }
  ]
}
```

## AWS CLI の認証情報の設定と動作確認

- aws profile の編集
  - `sample-service-terraform-backend-role` に IAM ユーザーの profile 経由でスイッチする profile を追加します。
  - `sample-service-terraform-deploy-role` に `sample-service-terraform-backend-role` 経由でスイッチする profile を追加します。

```ini fn=~/.aws/config
[default]
output = json
region = ap-northeast-1

[profile sample-service-terraform-backend]
region = ap-northeast-1
output = json

[profile sample-service-terraform-deploy]
region = ap-northeast-1
output = json
```

```ini fn=~/.aws/credentials
[default]
aws_access_key_id = IAM ユーザーのアクセスキー
aws_secret_access_key = IAM ユーザーのシークレットキー

[sample-service-terraform-backend]
role_arn = arn:aws:iam::999999999999:role/sample-service-terraform-backend-role
role_session_name = sample(IAM ユーザー名前)
external_id = sample-service-backend
source_profile = default

[sample-service-terraform-deploy]
role_arn = arn:aws:iam::999999999999:role/sample-service-terraform-deploy-role
external_id = sample-service-deploy
source_profile = sample-service-terraform-backend
```

- terraform の修正
  - `provider` の `profile` に `sample-service-terraform-deploy-role` にスイッチする profile 名を指定します。
  - `backend "s3"` の `profile` に `sample-service-terraform-backend-role` にスイッチする profile 名を指定します。

```hcl fn=main.tf
terraform {
  required_version = "= 0.14.7"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "= 3.9.0"
    }
  }
  backend "s3" {
    bucket = "sample-service-terraform-tfstate"
    key    = "cloudfront/terraform.tfstate"
    region = "ap-northeast-1"
    profile = "sample-service-terraform-backend"
  }
}

provider "aws" {
  profile = "sample-service-terraform-deploy"
  region = "ap-northeast-1"
}
```

- `terraform init`, `terraform plan/deploy/destroy`を実行してみて正常に終了すれば成功です。

## Terraform 実行時に AssumeRole で IAM ロールにスイッチロールする方法おまけ

`sample-service-terraform-backend-role` のスイッチに session_name の指定を強制しましたが、これをすることで Cloudtrail に以下のように出力されます。

```json fn=ログの一部(cognito作成時)
{
    "eventVersion": "1.08",
    "userIdentity": {
        "type": "AssumedRole",
        "principalId": "AAAAAAAAAAAAAAAAAAAAA:sample",
        "arn": "arn:aws:sts::999999999999:assumed-role/sample-service-terraform-deploy/sample",
        "accountId": "999999999999",
        "accessKeyId": "BBBBBBBBBBBBBBBBBBBB",
        "sessionContext": {
            "sessionIssuer": {
                "type": "Role",
                "principalId": "AAAAAAAAAAAAAAAAAAAAA:sample",
                "arn": "arn:aws:iam::999999999999:role/sample-service-terraform-deploy",
                "accountId": "999999999999",
                "userName": "sample-service-terraform-deploy"
            },
            "webIdFederationData": {},
            "attributes": {
                "mfaAuthenticated": "false",
                "creationDate": "2021-03-07T14:48:29Z"
            }
        }
    },
    "eventTime": "2021-03-07T14:48:32Z",
    "eventSource": "cognito-idp.amazonaws.com",
    "eventName": "CreateUserPool",
    "awsRegion": "ap-northeast-1",
    "sourceIPAddress": "2409:10:9780:c00:f09d:5f83:7147:9b65",
    "userAgent": "aws-sdk-go/1.34.26 (go1.14.5; darwin; amd64) APN/1.0 HashiCorp/1.0 Terraform/0.14.7 (+https://www.terraform.io)",
    "requestParameters": {
        "poolName": "Samplece_Service_Dev",
        "autoVerifiedAttributes": [
            "email"
        ],
        "usernameAttributes": [
            "email"
        ],
```

`principalId` に IAM ユーザーの名前が入るようになり、誰がリソースにどういった変更を加えたかなどがわかるようになります。

## Terraform 実行時に AssumeRole で IAM ロールにスイッチロールする方法まとめ

アクセスキーが流出した際のことを考慮に入れたデプロイ手法は色々あり、それを試してるうちにこんな感じになりました。
profile の設定を半ば強制してる感じで設定も共有する必要がありますがアクセスキーと profile の設定さえ教えればアクセスキーの上書きなど細々としたことやらずに済むので楽かなということでこれで運用してみようかなと思ってます。


Terraform の記事一覧

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

Terraform で SPA を配信する HTTPS 静的サイトのインフラを構築する[Route53 + ACM + CloudFront + S3 + CloudFront Functions(Basic 認証 + α)]

Terraform 実行時に AssumeRole で IAM ロールにスイッチロールする方法