What is sharding - Lindorm - Centre de documentation Alibaba Cloud

La gestion de données de séries temporelles à grande échelle nécessite de partitionner les données sur plusieurs collections tout en conservant la simplicité du code de votre application. Sans alias, vous devez mettre à jour les noms de collection dans le code applicatif chaque fois que vous faites tourner ou reconstruisez une collection. Les alias LindormSearch découplent le nom de collection utilisé par votre application de la collection physique contenant les données. Vous pouvez ainsi permuter des collections ou automatiser le partitionnement temporel sans modifier une seule ligne de code.

LindormSearch prend en charge deux types d'alias :

Type	Fonctionnalité	Cas d'utilisation
Alias standard	Pointe vers une ou plusieurs collections existantes. Modifiez la collection cible à tout moment.	Reconstructions d'index sans interruption de service, permutation de collections
Alias routé par temps	Crée automatiquement de nouvelles collections selon un calendrier et supprime celles qui ont expiré.	Charges de travail de séries temporelles, partitionnement des données actives

Cas d'utilisation

Gérer les données de séries temporelles : Créez une nouvelle collection chaque semaine afin que chaque collection ne contienne que des données récentes. Les requêtes portant sur les données actives analysent un index plus petit, ce qui améliore les performances. LindormSearch gère automatiquement la création et la suppression des collections ; aucune gestion manuelle des tables n'est nécessaire.
Reconstruire un index : Construisez une collection de remplacement en arrière-plan. Lorsqu'elle est prête, pointez l'alias vers la nouvelle collection. Les requêtes se poursuivent sans interruption et aucune modification de code n'est requise.

Créer un alias standard

Pointez un nouvel alias vers une collection existante :

curl "http://solrhost:8983/solr/admin/collections?action=CREATEALIAS&name=your_alias_name&collections=your_collection_name_A"

Le noyau LindormSearch transfère toutes les requêtes adressées à your_alias_name vers your_collection_name_A. Votre application accède uniquement au nom de l'alias et n'a pas besoin de connaître la collection sous-jacente.

Pour basculer l'alias vers une autre collection, utilisez ALIASPROP :

curl "http://solrhost:8983/solr/admin/collections?action=ALIASPROP&name=your_alias_name&collections=your_collection_name_B"

Votre application continue d'accéder à your_alias_name. Aucune modification de code n'est nécessaire.

Configurer les alias routés par temps (sharding automatique)

Un alias routé par temps crée une nouvelle collection à chaque intervalle et supprime celles qui ont expiré. L'exemple ci-dessous crée un alias hebdomadaire commençant il y a 30 jours et conserve les collections pendant 90 jours.

curl "http://solrhost:8983/solr/admin/collections?action=CREATEALIAS\
&name=test_router_alias\
&router.name=time\
&router.start=NOW-30DAYS/DAY\
&router.interval=%2B7DAY\
&router.autoDeleteAge=/DAY-90DAYS\
&router.field=your_timestamp_l\
&router.maxFutureMs=8640000000\
&create-collection.collection.configName=_indexer_default\
&create-collection.numShards=2"

Paramètres :

Paramètre	Exemple de valeur	Description
`router.name`	`time`	Stratégie de routage. Définissez sur `time` pour un routage basé sur le temps.
`router.start`	`NOW-30DAYS/DAY`	Début de la plage temporelle pour la première collection. `NOW-30DAYS/DAY` signifie que l'heure de début est fixée à 30 jours avant l'heure actuelle.
`router.interval`	`+7DAY`	Fréquence de création d'une nouvelle collection. `+7DAY` crée une collection par semaine.
`router.autoDeleteAge`	`/DAY-90DAYS`	Âge auquel une collection est supprimée. Les collections âgées de plus de 90 jours sont automatiquement retirées. Cette valeur doit représenter une période plus longue que celle définie par `router.start`.
`router.field`	`your_timestamp_l`	Champ de vos documents pilotant le routage. Il doit être présent dans chaque document. Types acceptés : `DATE` ou `LONG` (par exemple, `System.currentTimeMillis()`).
`router.maxFutureMs`	`8640000000`	Différence maximale autorisée, en millisecondes, entre la valeur du champ `router.field` et l'heure actuelle. La valeur `8640000000` ms équivaut à 100 jours ; ainsi, les documents datés de plus de 100 jours dans le futur ou le passé sont rejetés.
`create-collection.collection.configName`	`_indexer_default`	Ensemble de configuration utilisé par la collection. Pour plus d'informations, consultez la rubrique Mettre à jour l'ensemble de configuration.
`create-collection.numShards`	`2`	Nombre de shards par collection. Valeur par défaut : `2`.

Résultat : À partir d'il y a 30 jours, LindormSearch crée une collection tous les 7 jours, nommée test_router_alias_<date> (par exemple, test_router_alias_2020-03-04). Les collections âgées de plus de 90 jours sont automatiquement supprimées.

Tous les documents doivent inclure le champ spécifié dans router.field . Par défaut, toutes les collections associées à l'alias sont interrogées. Pour restreindre une requête à une plage temporelle spécifique, identifiez d'abord les collections cibles et transmettez leurs noms explicitement, comme illustré dans l'exemple Java ci-dessous.

Interroger une plage temporelle avec un horodatage de type LONG

Lorsque le champ router.field utilise un type LONG (millisecondes depuis l'époque), limitez une requête à une plage temporelle spécifique en résolvant l'alias vers ses collections constitutives et en filtrant celles qui chevauchent votre plage.

import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.impl.CloudSolrClient;
import org.apache.solr.client.solrj.impl.ClusterStateProvider;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.util.StrUtils;

import java.time.Instant;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.temporal.ChronoField;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;

public class SolrDemo {
  private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder()
      .append(DateTimeFormatter.ISO_LOCAL_DATE).appendPattern("[_HH[_mm[_ss]]]")
      .parseDefaulting(ChronoField.HOUR_OF_DAY, 0)
      .parseDefaulting(ChronoField.MINUTE_OF_HOUR, 0)
      .parseDefaulting(ChronoField.SECOND_OF_MINUTE, 0)
      .toFormatter(Locale.ROOT).withZone(ZoneOffset.UTC);

  private static final String zkHost = "localhost:2181/solr";
  private CloudSolrClient cloudSolrClient;
  private ClusterStateProvider clusterStateProvider;

  public SolrDemo() {
    cloudSolrClient = new CloudSolrClient.Builder(
        Collections.singletonList(zkHost), Optional.empty()).build();
    cloudSolrClient.connect();
    clusterStateProvider = cloudSolrClient.getClusterStateProvider();
  }

  public void close() throws Exception {
    if (null != cloudSolrClient) {
      cloudSolrClient.close();
    }
  }

  // Returns the collections that overlap the [start, end] epoch-millisecond range.
  // Collection names follow the pattern: test_router_alias_2020-03-04
  private List<String> findCollection(String aliasName, long start, long end) {
    List<String> collections = new ArrayList<>();
    if (start > end) {
      return collections;
    }

    if (clusterStateProvider.getState(aliasName) == null) {
      // Resolve the alias to its backing collections, e.g.:
      // [test_router_alias_2020-03-04, test_router_alias_2020-02-26, ...]
      List<String> aliasedCollections = clusterStateProvider.resolveAlias(aliasName);

      // Parse the date suffix from each collection name and map it to an Instant
      List<Map.Entry<Instant, String>> collectionsInstant = new ArrayList<>(aliasedCollections.size());
      for (String collectionName : aliasedCollections) {
        String dateTimePart = collectionName.substring(aliasName.length() + 1);
        Instant instant = DATE_TIME_FORMATTER.parse(dateTimePart, Instant::from);
        collectionsInstant.add(new AbstractMap.SimpleImmutableEntry<>(instant, collectionName));
      }

      // Keep only collections whose start time falls within the query range
      Instant startI = Instant.ofEpochMilli(start);
      Instant endI = Instant.ofEpochMilli(end);
      for (Map.Entry<Instant, String> entry : collectionsInstant) {
        Instant colStartTime = entry.getKey();
        if (!endI.isBefore(colStartTime)) {
          collections.add(entry.getValue());
          System.out.println("find collection: " + entry.getValue());
          if (!startI.isBefore(colStartTime)) {
            break;
          }
        }
      }
    } else {
      collections.add(aliasName);
    }
    System.out.println("query " + collections);
    return collections;
  }

  public void run() throws Exception {
    try {
      // Query the range [2020-03-07, 2020-03-10]
      long start = 1583538686312L;
      long end   = 1583797886000L;
      String aliasName = "test_router_alias";

      // Join matched collection names and run the query
      String collections = StrUtils.join(findCollection(aliasName, start, end), ',');
      QueryResponse res = cloudSolrClient.query(collections, new SolrQuery("*:*"));
      for (SolrDocument sd : res.getResults()) {
        System.out.println(sd.get("id") + " " + sd.get("gmtCreate_l"));
      }
    } finally {
      cloudSolrClient.close();
    }
  }

  public static void main(String[] args) throws Exception {
    SolrDemo solrDemo = new SolrDemo();
    solrDemo.run();
    solrDemo.close();
  }
}

Supprimer un alias

La suppression d'un alias n'affecte pas les collections sous-jacentes, quel que soit le type d'alias. Pour les alias routés par temps, les collections créées automatiquement persistent et doivent être supprimées manuellement.

Alias standard : Exécutez la commande suivante pour supprimer l'alias.

curl "http://solrhost:8983/solr/admin/collections?action=DELETEALIAS&name=your_alias_name"

Alias routé par temps : Après avoir supprimé l'alias, supprimez manuellement chaque collection associée.

Répertoriez toutes les collections pour identifier celles associées à l'alias :
```
curl "http://solrhost:8983/solr/admin/collections?action=LIST"
```
Les collections nommées test_router_alias_<date> sont associées à l'alias.

Supprimez l'alias :

curl "http://solrhost:8983/solr/admin/collections?action=DELETEALIAS&name=test_router_alias"

Supprimez chaque collection associée :

curl "http://solrhost:8983/solr/admin/collections?action=DELETE&name=<collection_name>"

Lindorm:Use sharding (aliases)

Cas d'utilisation

Créer un alias standard

Configurer les alias routés par temps (sharding automatique)

Interroger une plage temporelle avec un horodatage de type LONG

Supprimer un alias

Références