Cómo usar Terraform con Rockset


El objetivo de esta publicación de weblog es proporcionar las mejores prácticas sobre cómo usar terraform para configurar Rockset para ingerir los datos en dos colecciones, y cómo configurar una vista y consultar lambdas que se utilizan en una aplicación, además de mostrar el flujo de trabajo de la actualización posterior de las consultas lambdas. Esto imita cómo usamos terraform en Rockset para administrar los recursos de Rockset.

Terraform es el más standard usado DevOps herramienta para la gestión de infraestructuras, que te permite definir tu infraestructura como códigoy luego la herramienta tomará la configuración y calculará los pasos necesarios para pasar del estado precise al estado deseado.

Por último, veremos cómo usar las acciones de GitHub para ejecutar automáticamente terraform plan para solicitudes de extracción, y una vez que la solicitud de extracción se apruebe y fusione, se ejecutará terraform apply para hacer los cambios requeridos.

La configuración completa de terraformación utilizada en esta publicación de weblog está disponible aquí.

Terraformar

Para seguir por tu cuenta, necesitarás:

y también necesitas instalar terraformar en su computadora, que es tan easy como esto en macOS.

$ brew faucet hashicorp/faucet
$ brew set up hashicorp/faucet/terraform

(las instrucciones para otros sistemas operativos están disponibles en el enlace de arriba)

Configuración del proveedor

El primer paso para usar terraform es configurar los proveedores que usaremos, Rockset y AWS. Crea un archivo llamado _provider.tf con los contenidos.

terraform {
  required_providers {
        aws = {
            supply = "hashicorp/aws"
            model = "~> 4"
    }
    rockset = {
      supply = "rockset/rockset"
            model = "0.6.2"
    }
  }
}

supplier rockset {}
supplier aws {
    area = "us-west-2"
}

Ambos proveedores usan variables de entorno para leer las credenciales que requieren para acceder a los respectivos servicios.

  • conjunto de cohetes: ROCKSET_APIKEY y ROCKSET_APISERVER
  • AWS: AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEYo AWS_PROFILE

Configuración de back-end

Terraform guarda información sobre la infraestructura administrada y la configuración en un archivo de estado. Para compartir este estado entre ejecuciones locales en su computadora y ejecuciones automatizadas desde acciones de GitHub, usamos un llamado configuración de back-endque almacena el estado en un depósito de AWS S3, por lo que todas las invocaciones de terraform pueden usarlo.

backend "s3" {
    bucket = "rockset-community-terraform"
    key    = "weblog/state"
    area = "us-west-2"
  }

⚠️ Para una implementación de producción, asegúrese de configurar bloqueo de estado también.

Rol de IAM de AWS

Para permitir que Rockset ingiera el contenido de un depósito S3, primero debemos crear un rol de AWS IAM que Rockset utilizará para acceder al contenido del depósito. utiliza un fuente de datos para leer información sobre su organización Rockset, para que pueda configurar AWS correctamente.

information rockset_account present {}

useful resource "aws_iam_policy" "rockset-s3-integration" {
  identify   = var.rockset_role_name
  coverage = templatefile("${path.module}/information/coverage.json", {
    bucket = var.bucket
    prefix = var.bucket_prefix
  })
}

useful resource "aws_iam_role" "rockset" {
  identify               = var.rockset_role_name
  assume_role_policy = information.aws_iam_policy_document.rockset-trust-policy.json
}

information "aws_iam_policy_document" "rockset-trust-policy" {
  assertion {
    sid     = ""
    impact  = "Permit"
    actions = (
      "sts:AssumeRole"
    )
    principals {
      identifiers = (
        "arn:aws:iam::${information.rockset_account.present.account_id}:root"
      )
      kind = "AWS"
    }
    situation {
      check   = "StringEquals"
      values = (
        information.rockset_account.present.external_id
      )
      variable = "sts:ExternalId"
    }
  }
}

useful resource "aws_iam_role_policy_attachment" "rockset_s3_integration" {
  function       = aws_iam_role.rockset.identify
  policy_arn = aws_iam_policy.rockset-s3-integration.arn
}

Esto crea un rol de cuentas cruzadas de AWS IAM que Rockset puede usar para ingerir datos.

Integración Rockset S3

Ahora podemos crear la integración que permite a Rockset ingerir datos de S3, utilizando el rol de IAM anterior.

useful resource "time_sleep" "wait_30s" {
  depends_on      = (aws_iam_role.rockset)
  create_duration = "15s"
}

useful resource "rockset_s3_integration" "integration" {
  identify         = var.bucket
  aws_role_arn = aws_iam_role.rockset.arn
  depends_on   = (time_sleep.wait_30s)
}

⚠️ Puedes obtener un AWS cross-account function error si se salta el time_sleep recursoporque la función de AWS recién creada tarda unos segundos en propagarse, por lo que le evita tener que volver a ejecutar terraform apply otra vez.

colección rockset

Con la integración, ahora podemos crear un espacio de trabajo para contener todos los recursos que agregaremos y luego configurar un recopilación que ingiere datos utilizando la integración de S3 anterior.

useful resource rockset_workspace weblog {
  identify = "weblog"
}

useful resource "rockset_s3_collection" "assortment" {
  identify           = var.assortment
  workspace      = rockset_workspace.weblog.identify
  retention_secs = var.retention_secs
  supply {
    format           = "json"
    integration_name = rockset_s3_integration.integration.identify
    bucket           = var.bucket
    sample          = "public/films/*.json"
  }
}

Colección Kafka

A continuación, configuraremos una colección desde una fuente de Confluent Cloud y agregaremos un ingerir transformación que resume los datos.

useful resource "rockset_kafka_integration" "confluent" {
  identify         = var.bucket
  aws_role_arn = aws_iam_role.rockset.arn
  use_v3            = true
  bootstrap_servers = var.KAFKA_REST_ENDPOINT
  security_config = {
    api_key = var.KAFKA_API_KEY
    secret  = var.KAFKA_API_SECRET
  }
}

useful resource "rockset_kafka_collection" "orders" {
  identify           = "orders"
  workspace      = rockset_workspace.weblog.identify
  retention_secs = var.retention_secs
  supply {
    integration_name = rockset_kafka_integration.confluent.identify
  }
  field_mapping_query = file("information/transformation.sql")
}

El SQL para la transformación de ingesta se almacena en un archivo separado, que terraform inyecta en la configuración.

SELECT
    COUNT(i.orderid) AS orders,
    SUM(i.orderunits) AS models,
    i.deal with.zipcode,
    i.deal with.state,
    -- bucket information in 5 minute buckets
    TIME_BUCKET(MINUTES(5), TIMESTAMP_MILLIS(i.ordertime)) AS _event_time
FROM
    _input AS i
WHERE
    -- drop all data with an incorrect state
    i.deal with.state != 'State_'
GROUP BY
    _event_time,
    i.deal with.zipcode,
    i.deal with.state

Vista

Con los datos ingeridos en una colección podemos crear un vistaque limita a qué documentos de una colección se puede acceder a través de esa vista.

useful resource rockset_view english-movies {
  identify      = "english-movies"
  question     = file("information/view.sql")
  workspace = rockset_workspace.weblog.identify
  depends_on = (rockset_alias.films)
}

La vista necesita un explícito depends_on meta-argumento como terraform no interpreta el SQL para la vista que reside en un archivo separado.

Alias

Un alias es una forma de referirse a una colección existente con un nombre diferente. Esta es una forma conveniente de poder cambiar la colección que usa un conjunto de consultas, sin tener que actualizar el SQL para todas ellas.

useful resource rockset_alias films {
  collections = ("${rockset_workspace.weblog.identify}.${rockset_s3_collection.films.identify}")
  identify        = "films"
  workspace   = rockset_workspace.weblog.identify
}

Por ejemplo, si comenzamos a ingerir películas de una transmisión de Kafka, podemos actualizar el alias para hacer referencia a la nueva colección y todas las consultas comienzan a usarlo de inmediato.

Function

Creamos un rol que se limita a ejecutar consultas lambda únicamente en el espacio de trabajo del weblog y luego guardamos la clave de API en el almacén de parámetros de AWS Methods Supervisor para que el código que ejecutará la lambda la recupere posteriormente. De esta manera, las credenciales nunca tendrán que estar expuestas a un humano.

useful resource rockset_role read-only {
  identify = "blog-read-only"
  privilege {
    motion = "EXECUTE_QUERY_LAMBDA_WS"
    cluster = "*ALL*"
    resource_name = rockset_workspace.weblog.identify
  }
}

useful resource "rockset_api_key" "ql-only" {
  identify = "blog-ql-only"
  function = rockset_role.read-only.identify
}

useful resource "aws_ssm_parameter" "api-key" {
  identify  = "/rockset/weblog/apikey"
  kind  = "SecureString"
  worth = rockset_api_key.ql-only.key
}

consulta lambda

La consulta lambda almacena el SQL en un archivo separado y tiene una etiqueta que usa la variable terraform stable_version que cuando se establece, se utiliza para fijar el secure etiqueta a esa versión de la consulta lambda, y si no está configurada, apuntará a la última versión.

Colocar el SQL en un archivo separado no es un requisito, pero facilita la lectura y puede copiar/pegar el SQL en la consola de Rockset para probar los cambios manualmente. Otro beneficio es que revisar los cambios en el SQL es más fácil cuando no se entremezcla con otros cambios, como sucedería si se colocara en línea con la configuración de terraform.

SELECT
    title,
    TIME_BUCKET(
            YEARS(1),
            PARSE_TIMESTAMP('%Y-%m-%d', release_date)
        ) as 12 months,
  recognition
FROM
    weblog.films AS m
the place
    release_date != ''
  AND recognition > 10
GROUP BY
    12 months,
    title,
    recognition
order by
    recognition desc
useful resource "rockset_query_lambda" "top-rated" {
  identify      = "top-rated-movies"
  workspace = rockset_workspace.weblog.identify
  sql {
    question = file("information/top-rated.sql")
  }
}

useful resource "rockset_query_lambda_tag" "secure" {
  identify         = "secure"
  query_lambda = rockset_query_lambda.top-rated.identify
  model      = var.stable_version == "" ? rockset_query_lambda.top-rated.model : var.stable_version
  workspace    = rockset_workspace.weblog.identify
}

Aplicando la configuración

Con todos los archivos de configuración en su lugar, es hora de “aplicar” los cambios, lo que significa que terraform leerá los archivos de configuración e interrogará a Rockset y AWS sobre la configuración precise, y luego calculará qué pasos debe seguir para llegar a la configuración precise. estado last.

El primer paso es ejecutar terraform initque descargará todos los proveedores de terraform necesarios y configurará el backend de S3.

$ terraform init

Initializing the backend...

Efficiently configured the backend "s3"! Terraform will routinely
use this backend except the backend configuration modifications.

Initializing supplier plugins...
- Discovering hashicorp/aws variations matching "~> 4.0"...
- Discovering rockset/rockset variations matching "~> 0.6.2"...
- Putting in hashicorp/aws v4.39.0...
- Put in hashicorp/aws v4.39.0 (signed by HashiCorp)
- Putting in hashicorp/time v0.9.1...
- Put in hashicorp/time v0.9.1 (signed by HashiCorp)
- Putting in rockset/rockset v0.6.2...
- Put in rockset/rockset v0.6.2 (signed by a HashiCorp associate, key ID DB47D0C3DF97C936)

Companion and group suppliers are signed by their builders.
If you would like to know extra about supplier signing, you possibly can examine it right here:
https://www.terraform.io/docs/cli/plugins/signing.html

Terraform has created a lock file .terraform.lock.hcl to document the supplier
picks it made above. Embody this file in your model management repository
in order that Terraform can assure to make the identical picks by default when
you run "terraform init" sooner or later.

Terraform has been efficiently initialized!

Chances are you'll now start working with Terraform. Attempt working "terraform plan" to see
any modifications which might be required to your infrastructure. All Terraform instructions
ought to now work.

If you happen to ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working listing. If you happen to neglect, different
instructions will detect it and remind you to take action if mandatory.

A continuación corremos terraform plan para obtener una lista de los recursos que terraform va a crear y ver el orden en que los creará.

$ terraform plan
information.rockset_account.present: Studying...
information.rockset_account.present: Learn full after 0s (id=318212636800)
information.aws_iam_policy_document.rockset-trust-policy: Studying...
information.aws_iam_policy_document.rockset-trust-policy: Learn full after 0s (id=2982727827)

Terraform used the chosen suppliers to generate the next execution plan. Useful resource actions are indicated with the next symbols:
  + create

Terraform will carry out the next actions:

  # aws_iam_policy.rockset-s3-integration will probably be created
  + useful resource "aws_iam_policy" "rockset-s3-integration" {
      + arn       = (identified after apply)
      + id        = (identified after apply)
      + identify      = "rockset-s3-integration"
      + path      = "/"
      + coverage    = jsonencode(
            {
              + Id        = "RocksetS3IntegrationPolicy"
              + Assertion = (
                  + {
                      + Motion   = (
                          + "s3:ListBucket",
                        )
                      + Impact   = "Permit"
                      + Useful resource = (
                          + "arn:aws:s3:::rockset-community-datasets",
                        )
                      + Sid      = "BucketActions"
                    },
                  + {
                      + Motion   = (
                          + "s3:GetObject",
                        )
                      + Impact   = "Permit"
                      + Useful resource = (
                          + "arn:aws:s3:::rockset-community-datasets/*",
                        )
                      + Sid      = "ObjectActions"
                    },
                )
              + Model   = "2012-10-17"
            }
        )
      + policy_id = (identified after apply)
      + tags_all  = (identified after apply)
    }

...

# rockset_workspace.weblog will probably be created
  + useful resource "rockset_workspace" "weblog" {
      + created_by  = (identified after apply)
      + description = "created by Rockset terraform supplier"
      + id          = (identified after apply)
      + identify        = "weblog"
    }

Plan: 15 so as to add, 0 to alter, 0 to destroy.

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Word: You did not use the -out choice to avoid wasting this plan, so Terraform cannot assure to take precisely these actions in the event you run "terraform apply" now.                                                                                         7s 665ms  13:53:32

Revise la salida y verifique que esté haciendo lo que espera, y luego estará listo para aplicar los cambios usando terraform apply. Esto repite el resultado del plan y le pide que verifique que está listo para aplicar los cambios.

$ terraform apply
information.rockset_account.present: Studying...
information.rockset_account.present: Learn full after 0s (id=318212636800)
information.aws_iam_policy_document.rockset-trust-policy: Studying...
information.aws_iam_policy_document.rockset-trust-policy: Learn full after 0s (id=2982727827)

Terraform used the chosen suppliers to generate the next execution plan. Useful resource actions are indicated with the next symbols:
  + create

Terraform will carry out the next actions:

...

# time_sleep.wait_30s will probably be created
  + useful resource "time_sleep" "wait_30s" {
      + create_duration = "15s"
      + id              = (identified after apply)
    }

Plan: 16 so as to add, 0 to alter, 0 to destroy.

Do you need to carry out these actions?
  Terraform will carry out the actions described above.
  Solely 'sure' will probably be accepted to approve.

  Enter a worth: sure

rockset_workspace.weblog: Creating...
rockset_kafka_integration.confluent: Creating...
rockset_workspace.weblog: Creation full after 0s (id=weblog)
rockset_role.read-only: Creating...
rockset_query_lambda.top-rated: Creating...
rockset_role.read-only: Creation full after 1s (id=blog-read-only)
rockset_api_key.ql-only: Creating...
rockset_api_key.ql-only: Creation full after 0s (id=blog-ql-only)
rockset_query_lambda.top-rated: Creation full after 1s (id=weblog.top-rated-movies)
rockset_query_lambda_tag.secure: Creating...
rockset_query_lambda_tag.secure: Creation full after 0s (id=weblog.top-rated-movies.secure)
rockset_kafka_integration.confluent: Creation full after 1s (id=confluent-cloud-blog)
rockset_kafka_collection.orders: Creating...
aws_ssm_parameter.api-key: Creating...
aws_iam_role.rockset: Creating...
aws_iam_policy.rockset-s3-integration: Creating...
aws_ssm_parameter.api-key: Creation full after 1s (id=/rockset/weblog/apikey)
aws_iam_policy.rockset-s3-integration: Creation full after 1s (id=arn:aws:iam::459021908517:coverage/rockset-s3-integration)
aws_iam_role.rockset: Creation full after 2s (id=rockset-s3-integration)
aws_iam_role_policy_attachment.rockset_s3_integration: Creating...
time_sleep.wait_30s: Creating...
aws_iam_role_policy_attachment.rockset_s3_integration: Creation full after 0s (id=rockset-s3-integration-20221114233744029000000001)
rockset_kafka_collection.orders: Nonetheless creating... (10s elapsed)
time_sleep.wait_30s: Nonetheless creating... (10s elapsed)
time_sleep.wait_30s: Creation full after 15s (id=2022-11-14T23:37:58Z)
rockset_s3_integration.integration: Creating...
rockset_s3_integration.integration: Creation full after 0s (id=rockset-community-datasets)
rockset_s3_collection.films: Creating...
rockset_kafka_collection.orders: Nonetheless creating... (20s elapsed)
rockset_s3_collection.films: Nonetheless creating... (10s elapsed)
rockset_kafka_collection.orders: Nonetheless creating... (30s elapsed)
rockset_kafka_collection.orders: Creation full after 34s (id=weblog.orders)
rockset_s3_collection.films: Nonetheless creating... (20s elapsed)
rockset_s3_collection.films: Nonetheless creating... (30s elapsed)
rockset_s3_collection.films: Nonetheless creating... (40s elapsed)
rockset_s3_collection.films: Creation full after 43s (id=weblog.movies-s3)
rockset_alias.films: Creating...
rockset_alias.films: Creation full after 1s (id=weblog.films)
rockset_view.english-movies: Creating...
rockset_view.english-movies: Creation full after 1s (id=weblog.english-movies)

Apply full! Sources: 16 added, 0 modified, 0 destroyed.

Outputs:

latest-version = "0eb04bfed335946d"

Entonces, en aproximadamente 1 minuto, creó todos los recursos necesarios (y se pasaron 30 segundos esperando que se propagara el rol de IAM de AWS).

Actualización de recursos

Una vez que se ha aplicado la configuración inicial, es posible que tengamos que realizar modificaciones en uno o más recursos, por ejemplo, actualizar el SQL para una consulta lambda. Terraform nos ayudará a planificar estos cambios y solo aplicar lo que ha cambiado.

SELECT
    title,
    TIME_BUCKET(
            YEARS(1),
            PARSE_TIMESTAMP('%Y-%m-%d', release_date)
        ) as 12 months,
  recognition
FROM
    weblog.films AS m
the place
    release_date != ''
  AND recognition > 11
GROUP BY
    12 months,
    title,
    recognition
order by
    recognition desc

También actualizaremos el variables.tf archivo para fijar el secure etiqueta a la versión precise, de modo que el secure no cambia hasta que lo hayamos probado correctamente.

variable "stable_version" {
  kind = string
  default = "0eb04bfed335946d"
  description = "Question Lambda model for the secure tag. If empty, the most recent model is used."
}

Ahora podemos continuar y aplicar los cambios.

$ terraform apply
information.rockset_account.present: Studying...
rockset_workspace.weblog: Refreshing state... (id=weblog)
rockset_kafka_integration.confluent: Refreshing state... (id=confluent-cloud-blog)
rockset_role.read-only: Refreshing state... (id=blog-read-only)
rockset_query_lambda.top-rated: Refreshing state... (id=weblog.top-rated-movies)
rockset_kafka_collection.orders: Refreshing state... (id=weblog.orders)
rockset_api_key.ql-only: Refreshing state... (id=blog-ql-only)
rockset_query_lambda_tag.secure: Refreshing state... (id=weblog.top-rated-movies.secure)
information.rockset_account.present: Learn full after 1s (id=318212636800)
information.aws_iam_policy_document.rockset-trust-policy: Studying...
aws_iam_policy.rockset-s3-integration: Refreshing state... (id=arn:aws:iam::459021908517:coverage/rockset-s3-integration)
aws_ssm_parameter.api-key: Refreshing state... (id=/rockset/weblog/apikey)
information.aws_iam_policy_document.rockset-trust-policy: Learn full after 0s (id=2982727827)
aws_iam_role.rockset: Refreshing state... (id=rockset-s3-integration)
aws_iam_role_policy_attachment.rockset_s3_integration: Refreshing state... (id=rockset-s3-integration-20221114233744029000000001)
time_sleep.wait_30s: Refreshing state... (id=2022-11-14T23:37:58Z)
rockset_s3_integration.integration: Refreshing state... (id=rockset-community-datasets)
rockset_s3_collection.films: Refreshing state... (id=weblog.movies-s3)
rockset_alias.films: Refreshing state... (id=weblog.films)
rockset_view.english-movies: Refreshing state... (id=weblog.english-movies)

Terraform used the chosen suppliers to generate the next execution plan. Useful resource actions are indicated with the next symbols:
  ~ replace in-place

Terraform will carry out the next actions:

  # rockset_query_lambda.top-rated will probably be up to date in-place
  ~ useful resource "rockset_query_lambda" "top-rated" {
        id          = "weblog.top-rated-movies"
        identify        = "top-rated-movies"
      ~ model     = "0eb04bfed335946d" -> (identified after apply)
        # (3 unchanged attributes hidden)

      - sql {
          - question = <<-EOT
                SELECT
                    title,
                    TIME_BUCKET(
                            YEARS(1),
                            PARSE_TIMESTAMP('%Y-%m-%d', release_date)
                        ) as 12 months,
                  recognition
                FROM
                    weblog.films AS m
                the place
                    release_date != ''
                  AND recognition > 10
                GROUP BY
                    12 months,
                    title,
                    recognition
                order by
                    recognition desc
            EOT -> null
        }
      + sql {
          + question = <<-EOT
                SELECT
                    title,
                    TIME_BUCKET(
                            YEARS(1),
                            PARSE_TIMESTAMP('%Y-%m-%d', release_date)
                        ) as 12 months,
                  recognition
                FROM
                    weblog.films AS m
                the place
                    release_date != ''
                  AND recognition > 11
                GROUP BY
                    12 months,
                    title,
                    recognition
                ORDER BY
                    recognition desc
            EOT
        }
    }

Plan: 0 so as to add, 1 to alter, 0 to destroy.

Do you need to carry out these actions?
  Terraform will carry out the actions described above.
  Solely 'sure' will probably be accepted to approve.

  Enter a worth: sure

rockset_query_lambda.top-rated: Modifying... (id=weblog.top-rated-movies)
rockset_query_lambda.top-rated: Modifications full after 0s (id=weblog.top-rated-movies)

Apply full! Sources: 0 added, 1 modified, 0 destroyed.

Outputs:

latest-version = "2e268a64224ce9b2"

Como puede ver, actualizó la versión de consulta lambda a medida que cambiaba el SQL.

Ejecutando la consulta Lambda

Usted puede ejecutar la consulta lambda desde la línea de comando usando curl. Esto lee la apikey del Almacén de parámetros de AWS SSM y luego ejecuta la lambda usando el newest etiqueta.

$ curl --request POST 
    --url https://api.usw2a1.rockset.com/v1/orgs/self/ws/weblog/lambdas/top-rated-movies/tags/newest 
  -H "Authorization: ApiKey $(aws ssm get-parameters --with-decryption --query 'Parameters(*).{Worth:Worth}'  --output=textual content --names /rockset/weblog/apikey)" 
  -H 'Content material-Sort: software/json'

Cuando hayamos verificado que la consulta lambda devuelve los resultados correctos, podemos continuar y actualizar la etiqueta estable a la salida de la última terraform apply dominio.

variable "stable_version" {
  kind = string
  default = "2e268a64224ce9b2"
  description = "Question Lambda model for the secure tag. If empty, the most recent model is used."
}

Finalmente, aplique los cambios nuevamente para actualizar la etiqueta.

$ terraform apply
rockset_workspace.weblog: Refreshing state... (id=weblog)
information.rockset_account.present: Studying...
rockset_kafka_integration.confluent: Refreshing state... (id=confluent-cloud-blog)
rockset_query_lambda.top-rated: Refreshing state... (id=weblog.top-rated-movies)
rockset_role.read-only: Refreshing state... (id=blog-read-only)
rockset_kafka_collection.orders: Refreshing state... (id=weblog.orders)
rockset_api_key.ql-only: Refreshing state... (id=blog-ql-only)
rockset_query_lambda_tag.secure: Refreshing state... (id=weblog.top-rated-movies.secure)
information.rockset_account.present: Learn full after 1s (id=318212636800)
aws_iam_policy.rockset-s3-integration: Refreshing state... (id=arn:aws:iam::459021908517:coverage/rockset-s3-integration)
information.aws_iam_policy_document.rockset-trust-policy: Studying...
aws_ssm_parameter.api-key: Refreshing state... (id=/rockset/weblog/apikey)
information.aws_iam_policy_document.rockset-trust-policy: Learn full after 0s (id=2982727827)
aws_iam_role.rockset: Refreshing state... (id=rockset-s3-integration)
aws_iam_role_policy_attachment.rockset_s3_integration: Refreshing state... (id=rockset-s3-integration-20221114233744029000000001)
time_sleep.wait_30s: Refreshing state... (id=2022-11-14T23:37:58Z)
rockset_s3_integration.integration: Refreshing state... (id=rockset-community-datasets)
rockset_s3_collection.films: Refreshing state... (id=weblog.movies-s3)
rockset_alias.films: Refreshing state... (id=weblog.films)
rockset_view.english-movies: Refreshing state... (id=weblog.english-movies)

Terraform used the chosen suppliers to generate the next execution plan. Useful resource actions are indicated with the next symbols:
  ~ replace in-place

Terraform will carry out the next actions:

  # rockset_query_lambda_tag.secure will probably be up to date in-place
  ~ useful resource "rockset_query_lambda_tag" "secure" {
        id           = "weblog.top-rated-movies.secure"
        identify         = "secure"
      ~ model      = "0eb04bfed335946d" -> "2af51ce4d09ec319"
        # (2 unchanged attributes hidden)
    }

Plan: 0 so as to add, 1 to alter, 0 to destroy.

Do you need to carry out these actions?
  Terraform will carry out the actions described above.
  Solely 'sure' will probably be accepted to approve.

  Enter a worth: sure

rockset_query_lambda_tag.secure: Modifying... (id=weblog.top-rated-movies.secure)
rockset_query_lambda_tag.secure: Modifications full after 1s (id=weblog.top-rated-movies.secure)

Apply full! Sources: 0 added, 1 modified, 0 destroyed.

Outputs:

latest-version = "2e268a64224ce9b2"

Ahora el secure La etiqueta hace referencia a la última versión de consulta lambda.

Acción de GitHub

Para hacer uso de Infraestructura como código, colocaremos todas las configuraciones de terraformación en un repositorio git alojado por GitHub y utilizaremos el solicitud de extracción Flujo de trabajo para cambios de terraformación.

Configuraremos una acción de GitHub para que se ejecute automáticamente terraform plan para cada solicitud de incorporación de cambios y publique un comentario en el PR que muestre los cambios planificados.

Una vez que se aprueba y fusiona la solicitud de incorporación de cambios, se ejecutará terraform apply para realizar los cambios en su solicitud de extracción a Rockset.

Configuración

Esta sección es una versión abreviada de Automatice Terraform con GitHub Actionsque le explicará todos los pasos con mucho más detalle.

Guarde el siguiente archivo como .github/workflows/terraform.yml

identify: "Terraform"

on:
  push:
    branches:
      - grasp
  pull_request:

jobs:
  terraform:
    identify: "Terraform"
    runs-on: ubuntu-latest
    steps:
      - identify: Checkout
        makes use of: actions/checkout@v3

      - identify: Setup Terraform
        makes use of: hashicorp/setup-terraform@v1
        with:
          # terraform_version: 0.13.0:
          cli_config_credentials_token: ${{ secrets and techniques.TF_API_TOKEN }}

      - identify: Terraform Format
        id: fmt
        run: terraform fmt -check
        working-directory: terraform/weblog

      - identify: Terraform Init
        id: init
        run: terraform init
        working-directory: terraform/weblog

      - identify: Terraform Validate
        id: validate
        run: terraform validate -no-color
        working-directory: terraform/weblog

      - identify: Terraform Plan
        id: plan
        if: github.event_name == 'pull_request'
        run: terraform plan -no-color -input=false
        working-directory: terraform/weblog
        continue-on-error: true

      - makes use of: actions/github-script@v6
        if: github.event_name == 'pull_request'
        env:
          PLAN: "terraformn${{ steps.plan.outputs.stdout }}"
        with:
          github-token: ${{ secrets and techniques.GITHUB_TOKEN }}
          script: |
            const output = `#### Terraform Format and Fashion 🖌`${{ steps.fmt.consequence }}`
            #### Terraform Initialization ⚙️`${{ steps.init.consequence }}`
            #### Terraform Validation 🤖`${{ steps.validate.consequence }}`
            #### Terraform Plan 📖`${{ steps.plan.consequence }}`

            <particulars><abstract>Present Plan</abstract>

            ```n
            ${course of.env.PLAN}
            ```

            </particulars>

            *Pushed by: @${{ github.actor }}, Motion: `${{ github.event_name }}`*`;

            github.relaxation.points.createComment({
              issue_number: context.concern.quantity,
              proprietor: context.repo.proprietor,
              repo: context.repo.repo,
              physique: output
            })
          working-directory: terraform/weblog

      - identify: Terraform Plan Standing
        if: steps.plan.consequence == 'failure'
        run: exit 1

      - identify: Terraform Apply
        if: github.ref == 'refs/heads/grasp' && github.event_name == 'push'
        run: terraform apply -auto-approve -input=false
        working-directory: terraform/weblog

⚠️ Tenga en cuenta que esta es una configuración simplificada, para una configuración de grado de producción debe ejecutar terraform plan -out FILE y guarde el archivo, para que pueda usarse como entrada para terraform apply FILE, por lo que solo se aplican los cambios exactos aprobados en la solicitud de extracción. Se puede encontrar más información aquí.

Solicitud de extracción

Cuando creas un solicitud de extracción que cambia la configuración de terraform, el flujo de trabajo se ejecutará terraform plan y comentario en el PR, que contiene la salida del plan.


rockset-terraform-1

Esto le permite al revisor ver que el cambio se puede aplicar y, al hacer clic en “Mostrar plan”, puede ver exactamente qué cambios se van a realizar.

Cuando el PR se apruebe y se fusione con la rama principal, activará otro Flujo de trabajo de acción de GitHub run que aplica el cambio.


rockset-terraform-2

Ultimas palabras

Ahora tenemos una configuración de Infraestructura como código completamente funcional que implementará los cambios en su configuración de Rockset automáticamente después de la revisión por pares.



Related Articles

Comments

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Same Category

spot_img

Stay in touch!

Follow our Instagram