E-postindexering med Cloudera Search och HBase

I mitt tidigare inlägg lärde du dig hur man indexerar e-postmeddelanden i batch-läge, och i nästan realtid, med Apache Flume med MorphlineSolrSink. I det här inlägget kommer du att lära dig hur du indexerar e-postmeddelanden med Cloudera Search med Apache HBase och Lily HBase Indexer, som underhålls av NGDATA och Cloudera. (Om du inte har läst förra inlägget rekommenderar jag att du gör det för bakgrund innan du läser vidare.)

Vilken nästan realtidsmetod du ska välja, HBase Indexer eller Flume MorphlineSolrSink, beror helt på ditt användningsfall, men nedan är några saker att tänka på när du fattar det beslutet:

Är HBase ett optimalt lagringsmedium för det givna användningsfallet?
Är data redan inmatad i HBase?
Finns det något åtkomstmönster som kräver att filerna lagras i ett annat format än HFiles?
Om HBase inte körs för närvarande, finns det tillräckligt med hårdvaruresurser för att ta upp det?

Det finns två sätt att konfigurera Cloudera Search för att indexera dokument lagrade i HBase:att ändra konfigurationsfilerna direkt och starta Lily HBase Indexer manuellt eller som en tjänst, eller att konfigurera allt med Cloudera Manager. Det här inlägget kommer att fokusera på det senare, eftersom det är det överlägset enklaste sättet att aktivera sökning på HBase – eller någon annan tjänst på CDH, för den delen.

Förstå HBase Replication och Lily HBase Indexer

När Cloudera designade denna lösning identifierade de fyra huvudkraven för att göra HBase-indexering effektiv:

Indexeringsfördröjningen måste vara i nästan realtid (sekunder) och kan justeras
Solr Index måste så småningom överensstämma med HBase-tabellen medan infogningar, uppdateringar och borttagningar tillämpas på HBase
Indexeringsmekanismen måste vara skalbar och feltolerant
Indexeringsprocessen kan inte sakta ner HBase-skrivningen

För att uppfylla dessa krav använder Cloudera Search HBases inbyggda replikeringsmekanism. För de som inte är bekanta med HBase-replikering, här är en kort sammanfattning på mycket hög nivå:

När uppdateringar tillämpas på write-ahead-loggen (WAL), lyssnar HBase RegionServer på dessa uppdateringar i en separat tråd. När den trådens buffert är fylld eller den träffar slutet av filen, skickar den batcharna med alla replikerade uppdateringar till en peer RegionServer som körs på ett annat kluster. WAL är därför avgörande för att indexering ska fungera.

Cloudera Search använder HBase-replikeringsmekanismen, som lyssnar efter HBase-radmutationshändelser och, istället för att skicka uppdateringar till en annan RegionServer, skickar dem till Lily HBase Indexer. I sin tur använder Lily HBase Indexer Cloudera Morphlines transformationslogik, delar upp händelserna i Solr-fält och vidarebefordrar dem till Apache Solr Server.

Det finns stora fördelar med att använda HBase-replikering jämfört med att implementera samma funktionalitet i HBase-samprocessorer. För det första fungerar replikering parallellt och asynkront med data som matas in i HBase. Därför lägger Cloudera Search-indexering inte till någon latens eller driftsinstabilitet till rutinmässig HBase-drift. För det andra möjliggör användning av replikeringsmetoden sömlösa on-the-fly ändringar av transformationslogik. Omvänt krävs en omstart av RegionServer för att åstadkomma en förändring genom modifiering av samprocessor, vilket skulle göra data otillgängliga för HBase-användare. Det kanske viktigaste är att implementering av samprocessorer är ganska påträngande och, om det inte testas ordentligt, kan det störa HBases prestanda.

Detta flöde illustreras nedan:

Installera Cloudera Search och distribuera Lily HBase Indexer

Cloudera Manager laddar ner och distribuerar Cloudera Search som ett enda paket automatiskt. Allt du behöver göra är att klicka på "Paket"-ikonen i den övre navigeringen, välj Solr-versionen och ladda ner, distribuera och aktivera den:

Som nämnts tidigare beror Cloudera Search på HBase-replikering, och därför kommer det att aktiveras härnäst. Aktivera replikering genom att klicka på HBase Service->Konfiguration->Säkerhetskopiering och se till att "Aktivera HBase-replikering" och "Aktivera indexering" båda är markerade. Om det behövs, spara ändringarna och starta om HBase-tjänsten.

För att lägga till Lily HBase Indexer, gå till Tjänster->Lägg till tjänst , välj "Keystore Indexer" och lägg till den och peka på den HBase-instans som kommer att användas för e-postbearbetning:

Konfigurera Solr

Konfigurera sedan Solr exakt som beskrivits i föregående inlägg här.

Generera ett exempel på schema.xml-konfigurationsfil:

$ solrctl --zk localhost:2181/solr \
instancedir --generate $HOME/emailSearchConfig

Redigera filen schema.xml i $HOME/emailSearchConfig, med konfigurationsfilen som kommer att definiera fält som är relevanta för e-postbearbetning. En fullständig kopia av filen finns på den här länken.

Ladda upp Solr-konfigurationerna till ZooKeeper:

$ solrctl --zk localhost:2181/solr instancedir  \
--create email_collection $HOME/emailSearchConfig

Generera Solr-samlingen:

$ solrctl --zk localhost:2181/solr collection  \
--create email_collection -s 1

Registrera indexeraren

Detta steg behövs för att lägga till och konfigurera indexeraren och HBase-replikeringen. Kommandot nedan kommer att uppdatera ZooKeeper och lägga till myindexer som en replikeringspeer för HBase. Den kommer också att infoga konfigurationer i ZooKeeper, som Lily HBase Indexer kommer att använda för att peka på rätt samling i Solr.

$ hbase-indexer add-indexer -n myindexer -c indexer-config.xml  \
       -cp solr.zk=localhost:2181/solr  \
       -cp solr.collection=collection1

Argument:

-n myindexer – anger namnet på indexeraren som kommer att registreras i ZooKeeper
-c indexer-config.xml – konfigurationsfil som kommer att specificera indexerarens beteende
-cp solr.zk=localhost:2181/solr – anger platsen för ZooKeeper och Solr config. Detta bör uppdateras med den miljöspecifika platsen för ZooKeeper.
-cp solr.collection=collection1 – anger vilken samling som ska uppdateras. Kom ihåg Solr-konfigurationssteget där vi skapade samling1.

Filen index-config.xml är relativt okomplicerad i det här fallet; allt det gör är att specificera för indexeraren vilken tabell som ska titta på, klassen som kommer att användas som mappare (com.ngdata.hbaseindexer.morphline.MorphlineResultToSolrMapper) och platsen för Morphline-konfigurationsfilen. Mappningstypen är inställd på kolumn eftersom vi vill få varje cell som ett individuellt Solr-dokument. Som standard är mappningstyp inställd på rad , i vilket fall Solr-dokumentet blir hela raden.

Param name=”morphlineFile” anger platsen för Morphlines-konfigurationsfilen. Platsen kan vara en absolut sökväg till din Morphlines-fil, men eftersom du använder Cloudera Manager, ange den relativa sökvägen:"morphlines.conf".

Innehållet i hbase-indexer-konfigurationsfilen kan hittas på denna länk.

För fullständig referens till kommandot hbase-indexer räcker det att köra kommandot utan några argument:

$ hbase-indexer

Usage: hbase-indexer 
where  an option from one of these categories:

TOOLS
  add-indexer
  update-indexer
  delete-indexer
  list-indexers

PROCESS MANAGEMENT
  server           run the HBase Indexer server node

REPLICATION (EVENT PROCESSING) TOOLS
  replication-status
  replication-wait

PACKAGE MANAGEMENT
  classpath        dump hbase CLASSPATH
  version          print the version

 or
  CLASSNAME        run the class named CLASSNAME
Most commands print help when invoked w/o parameters.

Konfigurera och starta Lily HBase Indexer

Om du kommer ihåg, när du lade till Lily HBase Indexer, angav du instansen av HBase som den är associerad med. Därför behöver du inte göra det i detta steg. Du måste dock ange Morphlines-transformationslogiken som gör att denna indexerare kan analysera e-postmeddelanden och extrahera alla relevanta fält.

Gå till Tjänster och välj Lily HBase Indexer som du lagt till tidigare. Välj Konfigurationer->Visa och redigera->Service-Wide->Morphlines . Kopiera och klistra in morphlines-filen.

E-post morphlines-biblioteket kommer att utföra följande åtgärder:

1. Läs HBase-e-posthändelserna med kommandot extractHBaseCells
2. Dela upp den ostrukturerade texten i fält med kommandot grok
3. Om meddelande-ID saknas i e-postmeddelandet, generera det med kommandot generUUID
4. Konvertera datum/tidsstämpel till ett fält som Solr kommer att förstå, med kommandot convertTimestamp
5. Släpp alla extra fält som vi inte angav i schema.xml, med sanitizeUknownSolrFieldscommand

Kommandot extractHBaseCells förtjänar mer uppmärksamhet, eftersom det är det enda som skiljer sig åt med HBase Indexers morflinkonfiguration. Parametrarna är:

inputColumn – anger kolumner att prenumerera på (kan vara jokertecken)
outputFied – namnet på fältet dit data skickas
typ – typen av fält (det är sträng när det gäller e-posttext)
källa – kan vara värdefull eller kvalificerad; värde anger att cellvärdet ska indexeras

extractHBaseCells {
       mappings : [
        {
          inputColumn : "messages:*"
          outputField : "message"
          type : string
          source : value
          }
        ]
      }

Ladda ner en kopia av denna morphlines-fil härifrån.

En viktig anmärkning är att id-fältet kommer att genereras automatiskt av Lily HBase Indexer. Den inställningen kan konfigureras i filen index-config.xml ovan genom att ange attributet unique-key-field. Det är en bästa praxis att lämna standardnamnet för id - eftersom det inte specificerades i xml-filen ovan genererades standard-id-fältet och kommer att vara en kombination av RowID-Column Family-Column Name.

Spara nu ändringarna och starta Lily HBase Indexer från Cloudera Manager.

Konfigurera inkorgstabellen i HBase

Det finns många sätt att skapa tabellen i HBase programmatiskt (Java API, REST API eller liknande metod). Här kommer du att använda HBase-skalet för att skapa inkorgstabellen (avsiktligt genom att använda ett beskrivande kolumnfamiljenamn för att göra saker lättare att följa). I produktionsapplikationer bör efternamnet alltid vara kort, eftersom det alltid lagras med varje värde som en del av en cellnyckel. Följande kommando kommer att göra det och aktivera replikering på en kolumnfamilj som kallas "meddelanden":

hbase(main):003:0>  create 'inbox', {NAME => 'messages', REPLICATION_SCOPE => 1}

För att kontrollera att tabellen skapades korrekt kör följande kommando:

hbase(main):003:0> describe 'inbox'
DESCRIPTION                                                                ENABLED
 {NAME => 'inbox', FAMILIES => [{NAME => 'messages', DATA_BLOCK_ENCODING => ' true
 NONE', BLOOMFILTER => 'NONE', REPLICATION_SCOPE => '1', VERSIONS => '3',
 COMPRESSION => 'NONE', MIN_VERSIONS => '0', TTL => '2147483647', KEEP_DEL
 ETED_CELLS => 'false', BLOCKSIZE => '65536', IN_MEMORY => 'false', ENCODE
 _ON_DISK => 'true', BLOCKCACHE => 'true'}]}

Från denna tidpunkt kommer alla e-postmeddelanden som läggs in i tabellen "inkorgen" i kolumnfamiljens "meddelanden" att utlösa en händelse till Lily HBase Indexer, som kommer att bearbeta händelsen, dela upp den i fält och skicka den till Solr för indexering.

Schemat för inkorgstabellen är enkelt:Rad-ID är namnet på den person som denna inkorg tillhör. Varje cell är ett individuellt meddelande där kolumnen är ett unikt heltals-ID. Nedan är en ögonblicksbild av en exempeltabell som visas av Hues HBase-gränssnitt:

Åtkomst till data

Du kan välja mellan många visuella verktyg för att komma åt de indexerade e-postmeddelandena. Hue och Solr GUI är båda mycket bra alternativ. HBase möjliggör också ett antal åtkomsttekniker, inte bara från ett GUI utan också via HBase-skalet, API och till och med enkla skripttekniker.

Integration med Solr ger dig stor flexibilitet och kan även ge mycket enkla såväl som avancerade sökmöjligheter för din data. Att till exempel konfigurera Solr schema.xml-filen så att alla fält i e-postobjektet lagras i Solr tillåter användare att få tillgång till fullständiga meddelandekroppar via en enkel sökning, med en avvägning av lagringsutrymme och beräkningskomplexitet.

Alternativt kan du konfigurera Solr att endast lagra ett begränsat antal fält, såsom id, avsändare och ämne. Med dessa element kan användare snabbt söka i Solr och hämta meddelande-ID som i sin tur kan användas för att hämta hela meddelandet från HBase själv.

Exemplet nedan lagrar endast meddelande-ID i Solr men indexerar på alla fält inom e-postobjektet. Genom att söka i Solr i det här scenariot hämtas e-post-ID:n som du sedan kan använda för att fråga HBase. Den här typen av installation är idealisk för Solr eftersom den håller lagringskostnaderna låga och drar full nytta av Solrs indexeringsmöjligheter.

Skalskriptet nedan skickar en fråga till Solr Rest API för ett nyckelord "productId" och returnerar fältet "id" i CSV-format. Resultatet är en lista över dokument-ID:n som matchar frågan. Skriptet går sedan igenom ID:n och delar upp dem i rad-ID, kolumnfamilj och kolumnnamn, som används för att komma åt HBase via standard HBase REST API.

#!/bin/bash

#  Query SOLR and return the id field for every document
#  that contains the word resign
query_resp=$(curl -s 'http://spark:8983/solr/collection1_shard1_replica1/select?q=productId&fl=id&wt=csv')

# Loop through results of the previous command,
# and use the id to retrieve the cells from HBase via the HBase REST API
for i in  $query_resp
do
            if [ "$i" != "id" ]; then
            cmd=$(echo $i |awk -F'-' '{print "curl -s http://spark:20550/inbox/" $1 "/" $2 ":"  $3}')
            $cmd -H "Accept: application/x-protobuf "
            fi
done

Slutsats

I det här inlägget har du sett hur enkelt det är att indexera e-postmeddelanden som är lagrade i HBase — i nästan realtid och helt icke-påträngande till det huvudsakliga HBase-flödet. Sammanfattningsvis, tänk på dessa huvudsteg:

Aktivera replikering i HBase
Konfigurera Lily HBase Indexer korrekt
Använd Morphlines i Lily HBase Indexer för att hjälpa till med transformationer (ingen kodning krävs!)

Om du har haft möjlighet att läsa föregående inlägg kan du se att filen morphlines.conf är praktiskt taget identisk i alla tre fallen. Detta innebär att det är mycket enkelt att utöka sökanvändningsfallen över Hadoop-ekosystemet. Om data redan finns i HDFS, använd MapReduceIndexerTool för att indexera den. Om data anländer via Flume, använd SolrMorphlineSink med en identisk morphlines-fil. Om du senare bestämmer dig för att HBase passar användningsfallet, krävs bara en minimal ändring för att börja indexera celler i HBase:Lägg bara till kommandot extractHBaseCells i morphlines-filen.

Även om det här exemplet koncentrerar sig på e-postmeddelanden som ett användningsfall, kan den här metoden tillämpas i många andra scenarier där HBase används som lagrings- och åtkomstlager. Om ditt företag redan använder HBase för ett specifikt användningsfall, överväg att implementera Cloudera Search ovanpå det. Det kräver ingen kodning och kan verkligen öppna upp data för en mycket bredare publik i organisationen.

Jeff Shmain är en lösningsarkitekt på Cloudera.