Logo Zéphyrnet

Intelligence de données générative

Big Data

Présentation de la prise en charge de Terraform pour Amazon OpenSearch Ingestion | Services Web Amazon

Republié par Platon
Republié par Platon

Date :

Vues: 100

Aujourd'hui, nous lançons le support Terraform pour Ingestion d'Amazon OpenSearch. Terraform est un outil d'infrastructure en tant que code (IaC) qui vous aide à créer, déployer et gérer efficacement les ressources cloud. OpenSearch Ingestion est un collecteur de données sans serveur entièrement géré qui fournit des données de journal, de métrique et de trace en temps réel à Service Amazon OpenSearch domaines et Amazon OpenSearch sans serveur collections. Dans cet article, nous expliquons comment vous pouvez utiliser Terraform pour déployer des pipelines d'ingestion OpenSearch. A titre d'exemple, nous utilisons une source HTTP en entrée et un Service Amazon OpenSearch domaine (Index) en sortie.

Vue d'ensemble de la solution

Les étapes de cet article déploient un pipeline d'ingestion OpenSearch accessible au public avec Terraform, ainsi que d'autres ressources de prise en charge nécessaires au pipeline pour ingérer des données dans Amazon OpenSearch. Nous avons mis en œuvre le Didacticiel : Ingestion de données dans un domaine à l'aide d'Amazon OpenSearch Ingestion, en utilisant Terraform.

Nous créons les ressources suivantes avec Terraform :

Le pipeline que vous créez expose une source HTTP en entrée et un récepteur Amazon OpenSearch pour enregistrer des lots d'événements.

Pré-requis

Pour suivre les étapes de cet article, vous avez besoin des éléments suivants :

  • Un compte AWS actif.
  • Terraform installé sur votre machine locale. Pour plus d'informations, voir Installer Terraform.
  • Les autorisations IAM nécessaires requises pour créer les ressources AWS à l'aide de Terraform.
  • awscurl pour envoyer des requêtes HTTPS via la ligne de commande avec AWSSigv4 authentification. Pour obtenir des instructions sur l'installation de cet outil, consultez le GitHub repo.

Créer un annuaire

Dans Terraform, l'infrastructure est gérée sous forme de code, appelé Projet. Un projet Terraform contient divers fichiers de configuration Terraform, tels que main.tf, provider.tf, variables.tfet output.df . Créons un répertoire sur le serveur ou la machine que nous pouvons utiliser pour nous connecter aux services AWS à l'aide du Interface de ligne de commande AWS (AWS CLI) :

mkdir osis-pipeline-terraform-example

Accédez au répertoire.

cd osis-pipeline-terraform-example

Créer la configuration Terraform

Créez un fichier pour définir les ressources AWS.

touch main.tf

Entrez la configuration suivante dans main.tf et sauvegardez votre fichier :

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.36"
    }
  }

  required_version = ">= 1.2.0"
}

provider "aws" {
  region = "eu-central-1"
}

data "aws_region" "current" {}
data "aws_caller_identity" "current" {}
locals {
    account_id = data.aws_caller_identity.current.account_id
}

output "ingest_endpoint_url" {
  value = tolist(aws_osis_pipeline.example.ingest_endpoint_urls)[0]
}

resource "aws_iam_role" "example" {
  name = "exampleosisrole"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = "sts:AssumeRole"
        Effect = "Allow"
        Sid    = ""
        Principal = {
          Service = "osis-pipelines.amazonaws.com"
        }
      },
    ]
  })
}

resource "aws_opensearch_domain" "test" {
  domain_name           = "osi-example-domain"
  engine_version = "OpenSearch_2.7"
  cluster_config {
    instance_type = "r5.large.search"
  }
  encrypt_at_rest {
    enabled = true
  }
  domain_endpoint_options {
    enforce_https       = true
    tls_security_policy = "Policy-Min-TLS-1-2-2019-07"
  }
  node_to_node_encryption {
    enabled = true
  }
  ebs_options {
    ebs_enabled = true
    volume_size = 10
  }
 access_policies = <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "${aws_iam_role.example.arn}"
      },
      "Action": "es:*"
    }
  ]
}

EOF

}

resource "aws_iam_policy" "example" {
  name = "osis_role_policy"
  description = "Policy for OSIS pipeline role"
  policy = jsonencode({
    Version = "2012-10-17",
    Statement = [
        {
          Action = ["es:DescribeDomain"]
          Effect = "Allow"
          Resource = "arn:aws:es:${data.aws_region.current.name}:${local.account_id}:domain/*"
        },
        {
          Action = ["es:ESHttp*"]
          Effect = "Allow"
          Resource = "arn:aws:es:${data.aws_region.current.name}:${local.account_id}:domain/osi-test-domain/*"
        }
    ]
})
}

resource "aws_iam_role_policy_attachment" "example" {
  role       = aws_iam_role.example.name
  policy_arn = aws_iam_policy.example.arn
}

resource "aws_cloudwatch_log_group" "example" {
  name = "/aws/vendedlogs/OpenSearchIngestion/example-pipeline"
  retention_in_days = 365
  tags = {
    Name = "AWS Blog OSIS Pipeline Example"
  }
}

resource "aws_osis_pipeline" "example" {
  pipeline_name               = "example-pipeline"
  pipeline_configuration_body = <<-EOT
            version: "2"
            example-pipeline:
              source:
                http:
                  path: "/test_ingestion_path"
              processor:
                - date:
                    from_time_received: true
                    destination: "@timestamp"
              sink:
                - opensearch:
                    hosts: ["https://${aws_opensearch_domain.test.endpoint}"]
                    index: "application_logs"
                    aws:
                      sts_role_arn: "${aws_iam_role.example.arn}"   
                      region: "${data.aws_region.current.name}"
        EOT
  max_units                   = 1
  min_units                   = 1
  log_publishing_options {
    is_logging_enabled = true
    cloudwatch_log_destination {
      log_group = aws_cloudwatch_log_group.example.name
    }
  }
  tags = {
    Name = "AWS Blog OSIS Pipeline Example"
  }
  }

Créer les ressources

Initialisez le répertoire :

terraform init

Examinez le plan pour voir quelles ressources seront créées :

terraform plan

Appliquer la configuration et répondre yes pour exécuter le plan :

terraform apply

Le processus peut prendre environ 7 à 10 minutes.

Tester le pipeline

Après avoir créé les ressources, vous devriez voir le ingest_endpoint_url sortie affichée. Copiez cette valeur et exportez-la dans votre variable d'environnement :

export OSIS_PIPELINE_ENDPOINT_URL=<Replace with value copied>

Envoyez un exemple de journal avec awscurl. Remplacez le profil par votre profil AWS approprié pour les informations d'identification :

awscurl --service osis --region eu-central-1 -X POST -H "Content-Type: application/json" -d '[{"time":"2014-08-11T11:40:13+00:00","remote_addr":"122.226.223.69","status":"404","request":"GET http://www.k2proxy.com//hello.html HTTP/1.1","http_user_agent":"Mozilla/4.0 (compatible; WOW64; SLCC2;)"}]' https://$OSIS_PIPELINE_ENDPOINT_URL/test_ingestion_path

Vous devriez recevoir un 200 OK en réponse.

Pour vérifier que les données ont été ingérées dans le pipeline d'ingestion OpenSearch et enregistrées dans OpenSearch, accédez à OpenSearch et obtenez son point de terminaison de domaine. Remplace le <OPENSEARCH ENDPOINT URL> dans l'extrait ci-dessous et exécutez-le.

awscurl --service es --region eu-central-1 -X GET https://<OPENSEARCH ENDPOINT URL>/application_logs/_search | json_pp

Vous devriez voir le résultat comme ci-dessous :

Nettoyer

Pour détruire les ressources que vous avez créées, exécutez la commande suivante et répondez yes lorsque vous y êtes invité :

terraform destroy

Le processus peut prendre environ 30 à 35 minutes.

Conclusion

Dans cet article, nous avons montré comment utiliser Terraform pour déployer des pipelines d'ingestion OpenSearch. AWS propose divers NUMÉRIQUES pour que vous puissiez rapidement commencer à créer des pipelines à l'aide d'OpenSearch Ingestion et utiliser Terraform pour les déployer. Vous pouvez utiliser divers intégrations de pipelines pour ingérer rapidement des données de Amazon DynamoDB, Amazon Managed Streaming pour Apache Kafka (AmazonMSK), Lac de sécurité Amazon, Fluent Bit et bien d’autres. L'ingestion OpenSearch suivante blueprints vous permettent de créer des pipelines de données avec un minimum de modifications de configuration et de les gérer facilement à l'aide de Terraform. Pour en savoir plus, consultez le Documentation Terraform pour l'ingestion Amazon OpenSearch.

À propos des auteurs

Rahul Sharma est responsable de compte technique chez Amazon Web Services. Il est passionné par les technologies de données qui permettent d'exploiter les données en tant qu'actif stratégique et est basé à New York, New York.

Farhan Angullia est architecte d'applications cloud chez AWS Professional Services, basé à Singapour. Il se concentre principalement sur les applications modernes avec des modèles logiciels de microservices et préconise la mise en œuvre de pratiques CI/CD robustes afin d'optimiser le cycle de vie de livraison de logiciels pour les clients. Il aime contribuer à l’écosystème open source Terraform pendant son temps libre.

Arjun Nambiar est chef de produit chez Amazon OpenSearch Service. Il se concentre sur les technologies d'ingestion qui permettent d'ingérer des données provenant d'une grande variété de sources dans Amazon OpenSearch Service à grande échelle. Arjun s'intéresse aux systèmes distribués à grande échelle et aux technologies cloud natives et est basé à Seattle, Washington.

Muthu Pitchamani est un spécialiste de la recherche avec Amazon OpenSearch Service. Il construit des applications et des solutions de recherche à grande échelle. Muthu s'intéresse aux sujets de la mise en réseau et de la sécurité et est basé à Austin, au Texas.

spot_img

Dernières informations

spot_img

Copyright @ 2024 Platon Technologies Inc.