AWS OpenSearch

Un service puissant et scalable pour la recherche, l'analyse et la visualisation de données à grande échelle.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'AWS OpenSearch ?

Imaginez que vous possédez une immense bibliothèque avec des millions de livres, documents et articles. Comment trouveriez-vous rapidement une information précise sans avoir à parcourir chaque page manuellement ?

AWS OpenSearch est comme un bibliothécaire numérique ultra-efficace. Il vous aide à chercher, analyser et visualiser de grandes quantités de données en quelques secondes, peu importe leur volume ou leur complexité.

Pourquoi OpenSearch est si utile ?

Recherche puissante

Trouvez instantanément l'information dont vous avez besoin, même parmi des millions de documents.

Tableaux de bord visuels

Transformez vos données en graphiques et tableaux interactifs pour prendre de meilleures décisions.

Surveillance en temps réel

Détectez les problèmes dans vos applications ou systèmes dès qu'ils surviennent.

Flexibilité totale

Adaptez-le à vos besoins spécifiques, qu'il s'agisse d'un site e-commerce, d'une application mobile ou d'un système industriel.

En résumé, AWS OpenSearch aide les entreprises à trouver du sens dans leurs données, qu'il s'agisse de comprendre le comportement des clients, d'analyser des journaux techniques ou de surveiller des performances. C'est comme avoir une super-intelligence qui analyse continuellement toutes vos informations pour vous aider à prendre de meilleures décisions.

Pour les développeurs

Fonctionnement technique

AWS OpenSearch Service est un service géré qui facilite le déploiement, l'exploitation et la mise à l'échelle de clusters OpenSearch, un moteur de recherche et d'analyse distribué open-source basé sur Elasticsearch.

Les concepts fondamentaux

Architecture distribuée

OpenSearch fonctionne comme un système distribué composé de nœuds qui stockent et indexent les données, avec des mécanismes de réplication pour la haute disponibilité. Les données sont organisées en indices, eux-mêmes divisés en shards distribués sur plusieurs nœuds.

Indexation et mappings

OpenSearch utilise des mappings pour définir comment les documents et leurs champs sont stockés et indexés. Les mappings déterminent les types de données, les analyseurs de texte et d'autres paramètres d'indexation.

Création d'un index OpenSearch avec mappings

# Création d'un index dans OpenSearch
PUT /products
{
  "settings": {
    "index": {
      "number_of_shards": 4,
      "number_of_replicas": 1
    },
    "analysis": {
      "analyzer": {
        "french_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "french_stop",
            "french_stemmer"
          ]
        }
      },
      "filter": {
        "french_stop": {
          "type": "stop",
          "stopwords": "_french_"
        },
        "french_stemmer": {
          "type": "stemmer",
          "language": "french"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "id": { "type": "keyword" },
      "name": { 
        "type": "text",
        "analyzer": "french_analyzer",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "description": { 
        "type": "text", 
        "analyzer": "french_analyzer" 
      },
      "category": { "type": "keyword" },
      "price": { "type": "float" },
      "created_at": { "type": "date" },
      "in_stock": { "type": "boolean" },
      "tags": { "type": "keyword" },
      "location": { "type": "geo_point" }
    }
  }
}

Recherche et requêtes

OpenSearch offre un DSL (Domain Specific Language) puissant basé sur JSON pour formuler des requêtes complexes. Il prend en charge les recherches plein texte, les filtres, les agrégations, le géocodage, et bien plus encore.

Exemples de requêtes OpenSearch

# Recherche de base
GET /products/_search
{
  "query": {
    "multi_match": {
      "query": "téléphone portable sans fil",
      "fields": ["name^2", "description"]
    }
  }
}

# Recherche avec filtres et agrégations
GET /products/_search
{
  "query": {
    "bool": {
      "must": {
        "match": {
          "description": "téléphone"
        }
      },
      "filter": [
        { "term": { "category": "electronics" } },
        { "range": { "price": { "lte": 500 } } },
        { "term": { "in_stock": true } }
      ]
    }
  },
  "aggs": {
    "price_ranges": {
      "range": {
        "field": "price",
        "ranges": [
          { "to": 100 },
          { "from": 100, "to": 300 },
          { "from": 300, "to": 500 },
          { "from": 500 }
        ]
      }
    },
    "popular_categories": {
      "terms": {
        "field": "category",
        "size": 5
      }
    }
  },
  "sort": [
    { "_score": { "order": "desc" } },
    { "price": { "order": "asc" } }
  ],
  "from": 0,
  "size": 20
}

OpenSearch Dashboards

Interface utilisateur qui permet de visualiser les données d'OpenSearch via des tableaux de bord personnalisables. Elle offre des outils pour l'exploration des données, la création de visualisations et la configuration d'alertes.

Déploiement sur AWS

Infrastructure as Code avec CloudFormation

Exemple de déploiement d'un domaine OpenSearch avec AWS CloudFormation, incluant la configuration des instances, du stockage, de la sécurité et du chiffrement.

Template CloudFormation pour AWS OpenSearch

AWSTemplateFormatVersion: '2010-09-09'
Description: 'AWS CloudFormation Template for OpenSearch Service'

Resources:
  OpenSearchDomain:
    Type: AWS::OpenSearchService::Domain
    Properties:
      DomainName: products-search
      EngineVersion: OpenSearch_2.11
      ClusterConfig:
        InstanceType: r6g.large.search
        InstanceCount: 3
        ZoneAwarenessEnabled: true
        ZoneAwarenessConfig:
          AvailabilityZoneCount: 3
      EBSOptions:
        EBSEnabled: true
        VolumeType: gp3
        VolumeSize: 100
        Iops: 3000
      AccessPolicies:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              AWS: !Sub 'arn:aws:iam::${AWS::AccountId}:role/OpenSearchAccessRole'
            Action: 'es:*'
            Resource: !Sub 'arn:aws:es:${AWS::Region}:${AWS::AccountId}:domain/products-search/*'
      AdvancedOptions:
        rest.action.multi.allow_explicit_index: 'true'
        override_main_response_version: 'true'
      EncryptionAtRestOptions:
        Enabled: true
      NodeToNodeEncryptionOptions:
        Enabled: true
      DomainEndpointOptions:
        EnforceHTTPS: true
        TLSSecurityPolicy: 'Policy-Min-TLS-1-2-2019-07'
      AdvancedSecurityOptions:
        Enabled: true
        AnonymousAuthEnabled: false
        InternalUserDatabaseEnabled: true
        MasterUserOptions:
          MasterUserName: admin
          MasterUserPasswordSecretArn: !Sub 'arn:aws:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:OpenSearchMasterUser'
      Tags:
        - Key: Environment
          Value: Production
        - Key: Service
          Value: Search

Outputs:
  DomainEndpoint:
    Description: 'Domain endpoint for the OpenSearch service'
    Value: !GetAtt OpenSearchDomain.DomainEndpoint

Intégration avec les applications

Utilisation du client JavaScript

Comment intégrer OpenSearch dans une application JavaScript/Node.js pour effectuer des recherches avancées.

Client JavaScript pour AWS OpenSearch

// Utilisation du client JavaScript OpenSearch
import { Client } from '@opensearch-project/opensearch';
import { defaultProvider } from '@aws-sdk/credential-provider-node';
import createAwsOpensearchConnector from 'aws-opensearch-connector';

async function searchProducts(query, category, maxPrice) {
  // Initialisation du client avec authentification AWS IAM
  const awsCredentials = defaultProvider();
  const connector = createAwsOpensearchConnector({
    credentials: awsCredentials,
    region: process.env.AWS_REGION,
    getCredentials: function() {
      return awsCredentials();
    }
  });

  const client = new Client({
    node: `https://${process.env.OPENSEARCH_DOMAIN_ENDPOINT}`,
    Connection: connector,
    ssl: {
      rejectUnauthorized: true
    }
  });

  // Construction de la requête
  const searchParams = {
    index: 'products',
    body: {
      query: {
        bool: {
          must: {
            multi_match: {
              query: query,
              fields: ['name^2', 'description']
            }
          },
          filter: [
            { term: { in_stock: true } }
          ]
        }
      },
      sort: [
        { _score: { order: 'desc' } }
      ],
      size: 20
    }
  };

  // Ajout des filtres conditionnels
  if (category) {
    searchParams.body.query.bool.filter.push({
      term: { category: category }
    });
  }

  if (maxPrice) {
    searchParams.body.query.bool.filter.push({
      range: { price: { lte: maxPrice } }
    });
  }

  try {
    // Exécution de la recherche
    const response = await client.search(searchParams);
    
    // Traitement des résultats
    return {
      total: response.body.hits.total.value,
      hits: response.body.hits.hits.map(hit => ({
        id: hit._id,
        score: hit._score,
        ...hit._source
      }))
    };
  } catch (error) {
    console.error('Erreur lors de la recherche OpenSearch:', error);
    throw error;
  }
}

Collecte et traitement des logs

Configuration Logstash

Utilisation de Logstash pour collecter, transformer et envoyer des logs vers OpenSearch.

Configuration Logstash pour OpenSearch

input {
  file {
    path => "/var/log/application/*.log"
    start_position => "beginning"
    sincedb_path => "/var/lib/logstash/sincedb"
    codec => "json"
  }
  
  http {
    port => 8080
    codec => "json"
  }
}

filter {
  if [type] == "access_log" {
    grok {
      match => { "message" => "%{COMBINEDAPACHELOG}" }
    }
    date {
      match => [ "timestamp", "dd/MMM/yyyy:HH:mm:ss Z" ]
      target => "@timestamp"
    }
    geoip {
      source => "clientip"
      target => "geoip"
    }
    useragent {
      source => "agent"
      target => "user_agent"
    }
  }
  
  mutate {
    add_field => {
      "environment" => "${ENVIRONMENT:production}"
      "service_name" => "api-gateway"
    }
  }
}

output {
  opensearch {
    hosts => ["https://${OPENSEARCH_DOMAIN_ENDPOINT}:443"]
    index => "logs-%{+YYYY.MM.dd}"
    user => "${OPENSEARCH_USER}"
    password => "${OPENSEARCH_PASSWORD}"
    ssl => true
    ssl_certificate_verification => true
  }
}

Bonnes pratiques

Dimensionnement adapté - Choisissez le type et le nombre d'instances en fonction de votre volume de données et de votre charge de requêtes
Sharding optimal - Déterminez le nombre de shards en fonction de la taille de vos données et du nombre de nœuds
Mappings explicites - Définissez toujours des mappings explicites pour contrôler l'indexation et éviter le dynamic mapping pour les données critiques
Sécurité renforcée - Activez l'authentification, le chiffrement, le contrôle d'accès basé sur les rôles et le VPC
Surveillance et alertes - Configurez CloudWatch pour surveiller les métriques clés et définir des alarmes
Sauvegardes régulières - Utilisez les snapshots automatisés pour sauvegarder vos données sur S3

Applications concrètes

Cas d'usage

Moteurs de recherche E-commerce

Offrez une expérience de recherche rapide et pertinente sur votre site e-commerce, avec recherche par facettes, suggestions, correction orthographique et recherche de produits similaires.

Surveillance et observabilité

Centralisez les logs, métriques et traces pour surveiller vos applications, détecter les anomalies et dépanner rapidement les problèmes dans des environnements complexes.

Analyse de données

Explorez des ensembles de données massifs pour identifier des tendances, des modèles et des informations utiles à la prise de décision commerciale ou opérationnelle.

Détection de sécurité

Identifiez les menaces de sécurité en temps réel en analysant les journaux de sécurité, en détectant les comportements anormaux et en établissant des corrélations entre les événements.

Entreprises qui utilisent AWS OpenSearch

De nombreuses entreprises tirent parti d'AWS OpenSearch pour diverses applications critiques :

Airbnb

Netflix

Adobe

Shopify

Uber

Slack

Zalando

Ressources complémentaires

Toutes les compétences

Technologies associées