Azure Cosmos DB: eseguire analisi dei grafi con Spark e Apache TinkerPop GremlinAzure Cosmos DB: Perform graph analytics by using Spark and Apache TinkerPop Gremlin

Azure Cosmos DB è il servizio di database multimodello distribuito a livello globale di Microsoft.Azure Cosmos DB is the globally distributed, multi-model database service from Microsoft. È possibile creare ed eseguire query su database di documenti, coppie chiave-valore e grafi sfruttando i vantaggi offerti dalle funzionalità di scalabilità orizzontale e distribuzione globale alla base di Azure Cosmos DB.You can create and query document, key/value, and graph databases, all of which benefit from the global-distribution and horizontal-scale capabilities at the core of Azure Cosmos DB. Azure Cosmos DB supporta carichi di lavoro di grafi OLTP (Online Transaction Processing) basati sul linguaggio Apache TinkerPop Gremlin.Azure Cosmos DB supports online transaction processing (OLTP) graph workloads that use Apache TinkerPop Gremlin.

Spark è un progetto di Apache Software Foundation incentrato sull'elaborazione di dati OLAP (Online Analytical Processing) generici.Spark is an Apache Software Foundation project that's focused on general-purpose online analytical processing (OLAP) data processing. Spark offre un modello di calcolo distribuito in memoria/su disco simile al modello MapReduce di Hadoop.Spark provides a hybrid in-memory/disk-based distributed computing model that is similar to the Hadoop MapReduce model. È possibile distribuire Apache Spark nel cloud con Azure HDInsight.You can deploy Apache Spark in the cloud by using Azure HDInsight.

Combinando Azure Cosmos DB e Spark, è possibile eseguire carichi di lavoro sia OLTP che OLAP con Gremlin.By combining Azure Cosmos DB and Spark, you can perform both OLTP and OLAP workloads when you use Gremlin. Questa guida introduttiva illustra come eseguire query Gremlin su Azure Cosmos DB in un cluster Azure HDInsight Spark.This quick-start article demonstrates how to run Gremlin queries against Azure Cosmos DB on an Azure HDInsight Spark cluster.

PrerequisitiPrerequisites

Prima di poter eseguire questo esempio, è necessario soddisfare i prerequisiti seguenti:Before you can run this sample, you must have the following prerequisites:

  • Cluster Azure HDInsight Spark 2.0Azure HDInsight Spark cluster 2.0
  • JDK 1.8+ (eseguire apt-get install default-jdk se JDK non è disponibile)JDK 1.8+ (If you don't have JDK, run apt-get install default-jdk.)
  • Maven (eseguire apt-get install maven se Maven non è disponibile)Maven (If you don't have Maven, run apt-get install maven.)
  • Una sottoscrizione di Azure (Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.If you don't have an Azure subscription, create a free account before you begin.)An Azure subscription (Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.If you don't have an Azure subscription, create a free account before you begin.)

Per informazioni su come configurare un cluster Azure HDInsight Spark, vedere Provisioning di cluster HDInsight.For information about how to set up an Azure HDInsight Spark cluster, see Provisioning HDInsight clusters.

Creare un account di database Azure Cosmos DBCreate an Azure Cosmos DB database account

Per prima cosa, si crea un account di database con l'API Graph seguendo questa procedura:First, create a database account with the Graph API by doing the following:

  1. In una nuova finestra del browser accedere al portale di Azure.In a new browser window, sign in to the Azure portal.

  2. Fare clic su Nuovo > Database > Azure Cosmos DB.Click New > Databases > Azure Cosmos DB.

    Riquadro "Database" nel portale di Azure

  3. Nella pagina Nuovo account immettere le impostazioni per il nuovo account Azure Cosmos DB.In the New account page, enter the settings for the new Azure Cosmos DB account.

    ImpostazioneSetting Valore consigliatoSuggested value DescrizioneDescription
    IDID Immettere un nome univocoEnter a unique name Immettere un nome univoco per identificare l'account Azure Cosmos DB.Enter a unique name to identify this Azure Cosmos DB account. Poiché alI'ID fornito viene aggiunto documents.azure.com per creare l'URI, usare un ID univoco ma facilmente identificabile.Because documents.azure.com is appended to the ID that you provide to create your URI, use a unique but identifiable ID.

    L'ID può contenere solo lettere minuscole, numeri e il segno meno (-) e deve avere una lunghezza compresa tra 3 e 50 caratteri.The ID can contain only lowercase letters, numbers, and the hyphen (-) character, and it must contain 3 to 50 characters.
    APIAPI Gremlin (graph)Gremlin (graph) L'API determina il tipo di account da creare.The API determines the type of account to create. Azure Cosmos DB offre cinque API per soddisfare le esigenze dell'applicazione, ovvero SQL (database di documenti) Gremlin (grafo), MongoDB, SQL (database di documenti), Tabella di Azure e Cassandra, per ognuna delle quali è attualmente necessario un account separato.Azure Cosmos DB provides five APIs to suits the needs of your application: SQL (document database), Gremlin (graph database), MongoDB (document database), Azure Table, and Cassandra, each which currently require a separate account.

    Selezionare Gremlin (grafo) perché in questa esercitazione si crea un grafo disponibile per query con sintassi Gremlin.Select Gremlin (graph) because in this quickstart you are creating a graph that is queryable using Gremlin syntax.

    Altre informazioni sull'API GraphLearn more about the Graph API
    SottoscrizioneSubscription Sottoscrizione in usoYour subscription Selezionare la sottoscrizione di Azure da usare per l'account Azure Cosmos DB.Select Azure subscription that you want to use for this Azure Cosmos DB account.
    Gruppo di risorseResource group Immettere lo stesso nome univoco specificato sopra in IDEnter the same unique name as provided above in ID Immettere il nome di un nuovo gruppo di risorse per l'account.Enter a new resource-group name for your account. Per semplicità si può usare lo stesso nome usato come ID.For simplicity, you can use the same name as your ID.
    PercorsoLocation Selezionare l'area più vicina agli utentiSelect the region closest to your users Selezionare la posizione geografica in cui ospitare l'account Azure Cosmos DB.Select geographic location in which to host your Azure Cosmos DB account. Usare la località più vicina agli utenti per offrire loro la massima velocità di accesso ai dati.Use the location that's closest to your users to give them the fastest access to the data.
    Abilita ridondanza geograficaEnable geo-redundancy Lasciare vuotoLeave blank Consente di creare una versione replicata del database in una seconda area abbinata.This creates a replicated version of your database in a second (paired) region. Lasciare vuoto.Leave this blank.
    Aggiungi al dashboardPin to dashboard SelezionareSelect Selezionare questa casella per aggiungere il nuovo account di database al dashboard del portale e accedervi più facilmente.Select this box so that your new database account is added to your portal dashboard for easy access.

    Fare quindi clic su Crea.Then click Create.

    Pannello Nuovo account per Azure Cosmos DB

  4. La creazione dell'account richiede alcuni minuti,The account creation takes a few minutes. Durante la creazione dell'account il portale visualizza il riquadro Deploying Azure Cosmos DB (Distribuzione di Azure Cosmos DB) a destra, quindi potrebbe essere necessario scorrere a destra del dashboard per visualizzare il riquadro.During account creation the portal displays the Deploying Azure Cosmos DB tile on the right side, you may need to scroll right on your dashboard to see the tile. È presente anche un indicatore di stato nella parte superiore della schermata.There is also a progress bar displayed near the top of the screen. È possibile esaminare lo stato di avanzamento nelle due aree.You can watch either area for progress.

    Riquadro Notifiche del portale di Azure

    Al termine della creazione dell'account verrà visualizzata la pagina L'account Azure Cosmos DB è stato creato.Once the account is created, the Congratulations! Your Azure Cosmos DB account was created page is displayed.

Aggiungere una raccoltaAdd a collection

È ora possibile usare lo strumento Esplora dati nel portale di Azure per creare un database a grafo.You can now use the Data Explorer tool in the Azure portal to create a graph database.

  1. Dal menu a sinistra del portale di Azure scegliere Esplora dati (anteprima).In the Azure portal, in the menu on the left, select Data Explorer (Preview).

  2. In Esplora dati (anteprima) selezionare New Graph (Nuovo grafo).Under Data Explorer (Preview), select New Graph. Compilare quindi la pagina usando le informazioni seguenti:Then fill in the page by using the following information:

    Esplora dati nel portale di Azure

    ImpostazioneSetting Valore consigliatoSuggested value DescrizioneDescription
    ID databaseDatabase id sample-databasesample-database Immettere sample-database come nome del nuovo database.Enter sample-database as the name for the new database. I nomi dei database devono avere una lunghezza compresa tra 1 e 255 caratteri e non possono contenere / \ # ? o spazi finali.Database names must be between 1 and 255 characters and can't contain / \ # ? or a trailing space.
    Graph id (ID grafo)Graph id sample-graphsample-graph Immettere sample-graph come nome della nuova raccolta.Enter sample-graph as the name for your new collection. I nomi dei grafi presentano gli stessi requisiti relativi ai caratteri degli ID di database.Graph names have the same character requirements as database IDs.
    Capacità di archiviazioneStorage capacity 10 GB10 GB Lasciare il valore predefinito.Leave the default value. Indica la capacità di archiviazione del database.This is the storage capacity of the database.
    Velocità effettivaThroughput 400 UR/s400 RUs Lasciare il valore predefinito.Leave the default value. È possibile aumentare la velocità effettiva in un secondo momento se si desidera ridurre la latenza.You can scale up the throughput later if you want to reduce latency.
    Chiave di partizionePartition key /firstName/firstName Chiave di partizione che distribuisce i dati in modo uniforme a ogni partizione.A partition key that distributes data evenly to each partition. Quando si crea un grafo ad alte prestazioni, è importante selezionare la chiave di partizione corretta.Selecting the correct partition key is important in creating a performant graph. Per altre informazioni, vedere Progettazione per il partizionamento.For more information, see Designing for partitioning.
  3. Dopo avere compilato il modulo, fare clic su OK.After the form is filled out, select OK.

Ottenere Apache TinkerPopGet Apache TinkerPop

Ottenere Apache TinkerPop seguendo questa procedura:Get Apache TinkerPop by doing the following:

  1. Accedere in remoto al nodo master del cluster HDInsight ssh tinkerpop3-cosmosdb-demo-ssh.azurehdinsight.net.Remote to the master node of the HDInsight cluster ssh tinkerpop3-cosmosdb-demo-ssh.azurehdinsight.net.

  2. Clonare il codice sorgente di TinkerPop3, compilarlo in locale ed eseguirne l'installazione nella cache di Maven.Clone the TinkerPop3 source code, build it locally, and install it to Maven cache.

    git clone https://github.com/apache/tinkerpop.git
    cd tinkerpop
    mvn clean install
    
  3. Installare il plug-in Spark-GremlinInstall the Spark-Gremlin plug-in

    a.a. L'installazione del plug-in viene gestita da Grape.The installation of the plug-in is handled by Grape. Inserire le informazioni relative ai repository per Grape in modo da consentire il download del plug-in e delle relative dipendenze.Populate the repositories information for Grape so it can download the plug-in and its dependencies.

    Creare il file di configurazione di Grape, se non è presente in ~/.groovy/grapeConfig.xml.Create the grape configuration file if it's not present at ~/.groovy/grapeConfig.xml. Usare le seguenti impostazioni:Use the following settings:

    <ivysettings>
    <settings defaultResolver="downloadGrapes"/>
    <resolvers>
        <chain name="downloadGrapes">
        <filesystem name="cachedGrapes">
            <ivy pattern="${user.home}/.groovy/grapes/[organisation]/[module]/ivy-[revision].xml"/>
            <artifact pattern="${user.home}/.groovy/grapes/[organisation]/[module]/[type]s/[artifact]-[revision].[ext]"/>
        </filesystem>
        <ibiblio name="codehaus" root="http://repository.codehaus.org/" m2compatible="true"/>
        <ibiblio name="central" root="http://central.maven.org/maven2/" m2compatible="true"/>
        <ibiblio name="jitpack" root="https://jitpack.io" m2compatible="true"/>
        <ibiblio name="java.net2" root="http://download.java.net/maven/2/" m2compatible="true"/>
        <ibiblio name="apache-snapshots" root="http://repository.apache.org/snapshots/" m2compatible="true"/>
        <ibiblio name="local" root="file:${user.home}/.m2/repository/" m2compatible="true"/>
        </chain>
    </resolvers>
    </ivysettings>
    

    b.b. Avviare la console Gremlin bin/gremlin.sh.Start Gremlin console bin/gremlin.sh.

    c.c. Installare il plug-in Spark-Gremlin con la versione 3.3.0-SNAPSHOT compilata nei passaggi precedenti:Install the Spark-Gremlin plug-in with version 3.3.0-SNAPSHOT, which you built in the previous steps:

    $ bin/gremlin.sh
    
            \,,,/
            (o o)
    -----oOOo-(3)-oOOo-----
    plugin activated: tinkerpop.server
    plugin activated: tinkerpop.utilities
    plugin activated: tinkerpop.tinkergraph
    gremlin> :install org.apache.tinkerpop spark-gremlin 3.3.0-SNAPSHOT
    ==>loaded: [org.apache.tinkerpop, spark-gremlin, 3.3.0-SNAPSHOT] - restart the console to use [tinkerpop.spark]
    gremlin> :q
    $ bin/gremlin.sh
    
            \,,,/
            (o o)
    -----oOOo-(3)-oOOo-----
    plugin activated: tinkerpop.server
    plugin activated: tinkerpop.utilities
    plugin activated: tinkerpop.tinkergraph
    gremlin> :plugin use tinkerpop.spark
    ==>tinkerpop.spark activated
    
  4. Controllare se Hadoop-Gremlin è attivato con :plugin list.Check to see whether Hadoop-Gremlin is activated with :plugin list. Disabilitare questo plug-in perché potrebbe interferire con il plug-in Spark-Gremlin :plugin unuse tinkerpop.hadoop.Disable this plug-in, because it could interfere with the Spark-Gremlin plug-in :plugin unuse tinkerpop.hadoop.

Preparare le dipendenze di TinkerPop3Prepare TinkerPop3 dependencies

Durante la compilazione di TinkerPop3 nel passaggio precedente sono state estratte nella directory di destinazione anche tutte le dipendenze in formato JAR per Spark e Hadoop.When you built TinkerPop3 in the previous step, the process also pulled all jar dependencies for Spark and Hadoop in the target directory. Usare i file JAR preinstallati con HDI ed effettuare il pull delle dipendenze aggiuntive solo se necessario.Use the jars that are pre-installed with HDI, and pull in additional dependencies only as necessary.

  1. Passare alla directory di destinazione della console Gremlin in tinkerpop/gremlin-console/target/apache-tinkerpop-gremlin-console-3.3.0-SNAPSHOT-standalone.Go to the Gremlin Console target directory at tinkerpop/gremlin-console/target/apache-tinkerpop-gremlin-console-3.3.0-SNAPSHOT-standalone.

  2. Spostare tutti i file JAR da ext/ a lib/: find ext/ -name '*.jar' -exec mv {} lib/ \;.Move all jars under ext/ to lib/: find ext/ -name '*.jar' -exec mv {} lib/ \;.

  3. Rimuovere tutte le librerie JAR in lib/ che non sono incluse nell'elenco seguente:Remove all jar libraries under lib/ that are not in the following list:

    # TinkerPop3
    gremlin-console-3.3.0-SNAPSHOT.jar
    gremlin-core-3.3.0-SNAPSHOT.jar       
    gremlin-groovy-3.3.0-SNAPSHOT.jar     
    gremlin-shaded-3.3.0-SNAPSHOT.jar     
    hadoop-gremlin-3.3.0-SNAPSHOT.jar     
    spark-gremlin-3.3.0-SNAPSHOT.jar      
    tinkergraph-gremlin-3.3.0-SNAPSHOT.jar
    
    # Gremlin depedencies
    asm-3.2.jar                                
    avro-1.7.4.jar                             
    caffeine-2.3.1.jar                         
    cglib-2.2.1-v20090111.jar                  
    gbench-0.4.3-groovy-2.4.jar                
    gprof-0.3.1-groovy-2.4.jar                 
    groovy-2.4.9-indy.jar                      
    groovy-2.4.9.jar                           
    groovy-console-2.4.9.jar                   
    groovy-groovysh-2.4.9-indy.jar             
    groovy-json-2.4.9-indy.jar                 
    groovy-jsr223-2.4.9-indy.jar               
    groovy-sql-2.4.9-indy.jar                  
    groovy-swing-2.4.9.jar                     
    groovy-templates-2.4.9.jar                 
    groovy-xml-2.4.9.jar                       
    hadoop-yarn-server-nodemanager-2.7.2.jar   
    hppc-0.7.1.jar                             
    javatuples-1.2.jar                         
    jaxb-impl-2.2.3-1.jar                      
    jbcrypt-0.4.jar                            
    jcabi-log-0.14.jar                         
    jcabi-manifests-1.1.jar                    
    jersey-core-1.9.jar                        
    jersey-guice-1.9.jar                       
    jersey-json-1.9.jar                        
    jettison-1.1.jar                           
    scalatest_2.11-2.2.6.jar                   
    servlet-api-2.5.jar                        
    snakeyaml-1.15.jar                         
    unused-1.0.0.jar                           
    xml-apis-1.3.04.jar                        
    

Ottenere il connettore Spark per Azure Cosmos DBGet the Azure Cosmos DB Spark connector

  1. Ottenere il connettore Spark per Azure Cosmos DB azure-documentdb-spark-0.0.3-SNAPSHOT.jar e Cosmos DB Java SDK azure-documentdb-1.10.0.jar dalla relativa pagina in Github.Get the Azure Cosmos DB Spark connector azure-documentdb-spark-0.0.3-SNAPSHOT.jar and Cosmos DB Java SDK azure-documentdb-1.10.0.jar from Azure Cosmos DB Spark Connector on GitHub.

  2. In alternativa, è possibile eseguirne la compilazione in locale.Alternatively, you can build it locally. Dato che l'ultima versione di Spark-Gremlin è stata compilata con Spark 1.6.1 e non è compatibile con la versione Spark 2.0.2 attualmente usata nel connettore Spark per Azure Cosmos DB, è possibile compilare il codice di TinkerPop3 più recente e installare i file JAR manualmente.Because the latest version of Spark-Gremlin was built with Spark 1.6.1 and is not compatible with Spark 2.0.2, which is currently used in the Azure Cosmos DB Spark connector, you can build the latest TinkerPop3 code and install the jars manually. Eseguire le operazioni seguenti:Do the following:

    a.a. Clonare il connettore Spark per Azure Cosmos DB.Clone the Azure Cosmos DB Spark connector.

    b.b. Compilare TinkerPop3 (operazione già eseguita nei passaggi precedenti)Build TinkerPop3 (already done in previous steps). e installare tutti i file JAR di TinkerPop 3.3.0-SNAPSHOT in locale.Install all TinkerPop 3.3.0-SNAPSHOT jars locally.

    mvn install:install-file -Dfile="gremlin-core-3.3.0-SNAPSHOT.jar" -DgroupId=org.apache.tinkerpop -DartifactId=gremlin-core -Dversion=3.3.0-SNAPSHOT -Dpackaging=jar
    mvn install:install-file -Dfile="gremlin-groovy-3.3.0-SNAPSHOT.jar" -DgroupId=org.apache.tinkerpop -DartifactId=gremlin-groovy -Dversion=3.3.0-SNAPSHOT -Dpackaging=jar`
    mvn install:install-file -Dfile="gremlin-shaded-3.3.0-SNAPSHOT.jar" -DgroupId=org.apache.tinkerpop -DartifactId=gremlin-shaded -Dversion=3.3.0-SNAPSHOT -Dpackaging=jar`
    mvn install:install-file -Dfile="hadoop-gremlin-3.3.0-SNAPSHOT.jar" -DgroupId=org.apache.tinkerpop -DartifactId=hadoop-gremlin -Dversion=3.3.0-SNAPSHOT -Dpackaging=jar`
    mvn install:install-file -Dfile="spark-gremlin-3.3.0-SNAPSHOT.jar" -DgroupId=org.apache.tinkerpop -DartifactId=spark-gremlin -Dversion=3.3.0-SNAPSHOT -Dpackaging=jar`
    mvn install:install-file -Dfile="tinkergraph-gremlin-3.3.0-SNAPSHOT.jar" -DgroupId=org.apache.tinkerpop -DartifactId=tinkergraph-gremlin -Dversion=3.3.0-SNAPSHOT -Dpackaging=jar`
    

    c.c. Aggiornare tinkerpop.version azure-documentdb-spark/pom.xml a 3.3.0-SNAPSHOT.Update tinkerpop.version azure-documentdb-spark/pom.xml to 3.3.0-SNAPSHOT.

    d.d. Eseguire la compilazione con Maven.Build with Maven. I file JAR necessari vengono inseriti in target e target/alternateLocation.The needed jars are placed in target and target/alternateLocation.

    git clone https://github.com/Azure/azure-cosmosdb-spark.git
    cd azure-documentdb-spark
    mvn clean package
    
  3. Copiare i file JAR elencati in precedenza in una directory locale in ~/azure-documentdb-spark:Copy the previously mentioned jars to a local directory at ~/azure-documentdb-spark:

    $ azure-documentdb-spark:
    mkdir ~/azure-documentdb-spark
    cp target/azure-documentdb-spark-0.0.3-SNAPSHOT.jar ~/azure-documentdb-spark
    cp target/alternateLocation/azure-documentdb-1.10.0.jar ~/azure-documentdb-spark
    

Distribuire le dipendenze nei nodi di lavoro SparkDistribute the dependencies to the Spark worker nodes

  1. Dato che la trasformazione dei dati dei grafi dipende da TinkerPop3, è necessario distribuire le relative dipendenze in tutti i nodi di lavoro Spark.Because the transformation of graph data depends on TinkerPop3, you must distribute the related dependencies to all Spark worker nodes.

  2. Copiare le dipendenze Gremlin elencate in precedenza, il file JAR del connettore Spark per CosmosDB e CosmosDB Java SDK nei nodi di lavoro seguendo questa procedura:Copy the previously mentioned Gremlin dependencies, the CosmosDB Spark connector jar, and CosmosDB Java SDK to the worker nodes by doing the following:

    a.a. Copiare tutti i file JAR in ~/azure-documentdb-spark.Copy all the jars into ~/azure-documentdb-spark.

    $ /home/sshuser/tinkerpop/gremlin-console/target/apache-tinkerpop-gremlin-console-3.3.0-SNAPSHOT-standalone:
    cp lib/* ~/azure-documentdb-spark
    

    b.b. Ottenere l'elenco di tutti i nodi di lavoro Spark, disponibile nel dashboard Ambari, nell'elenco Spark2 Clients della sezione Spark2.Get the list of all Spark worker nodes, which you can find on Ambari Dashboard, in the Spark2 Clients list in the Spark2 section.

    c.c. Copiare la directory in ogni nodo.Copy that directory to each of the nodes.

    scp -r ~/azure-documentdb-spark sshuser@wn0-cosmos:/home/sshuser
    scp -r ~/azure-documentdb-spark sshuser@wn1-cosmos:/home/sshuser
    ...
    

Configurare le variabili di ambienteSet up the environment variables

  1. Trovare la versione HDP del cluster Spark,Find the HDP version of the Spark cluster. corrispondente al nome di directory in /usr/hdp/ (ad esempio, 2.5.4.2-7).It is the directory name under /usr/hdp/ (for example, 2.5.4.2-7).

  2. Configurare hdp.version per tutti i nodi.Set hdp.version for all nodes. Nel dashboard Ambari passare a YARN section > Configs > Advanced (Sezione YARN > Configurazioni > Avanzate) e seguire questa procedura:In Ambari Dashboard, go to YARN section > Configs > Advanced, and then do the following:

    a.a. In Custom yarn-site aggiungere una nuova proprietà hdp.version con il valore della versione di HDP nel nodo master.In Custom yarn-site, add a new property hdp.version with the value of the HDP version on the master node.

    b.b. Salvare le configurazioni.Save the configurations. Verranno visualizzati avvisi che è possibile ignorare.There are warnings, which you can ignore.

    c.c. Riavviare i servizi Oozie e YARN come indicato dalle icone di notifica.Restart the YARN and Oozie services as the notification icons indicate.

  3. Impostare le variabili di ambiente seguenti nel nodo master, sostituendo i valori in base alle esigenze:Set the following environment variables on the master node (replace the values as appropriate):

    export HADOOP_GREMLIN_LIBS=/home/sshuser/tinkerpop/gremlin-console/target/apache-tinkerpop-gremlin-console-3.3.0-SNAPSHOT-standalone/ext/spark-gremlin/lib
    export CLASSPATH=$CLASSPATH:$HADOOP_CONF_DIR:/usr/hdp/current/spark2-client/jars/*:/home/sshuser/azure-documentdb-spark/*
    export HDP_VERSION=2.5.4.2-7
    export HADOOP_HOME=${HADOOP_HOME:-/usr/hdp/current/hadoop-client}
    

Preparare la configurazione per i grafiPrepare the graph configuration

  1. Creare un file di configurazione con i parametri di connessione di Azure Cosmos DB e le impostazioni di Spark e inserirlo in tinkerpop/gremlin-console/target/apache-tinkerpop-gremlin-console-3.3.0-SNAPSHOT-standalone/conf/hadoop/gremlin-spark.properties.Create a configuration file with the Azure Cosmos DB connection parameters and Spark settings, and put it at tinkerpop/gremlin-console/target/apache-tinkerpop-gremlin-console-3.3.0-SNAPSHOT-standalone/conf/hadoop/gremlin-spark.properties.

    gremlin.graph=org.apache.tinkerpop.gremlin.hadoop.structure.HadoopGraph
    gremlin.hadoop.jarsInDistributedCache=true
    gremlin.hadoop.defaultGraphComputer=org.apache.tinkerpop.gremlin.spark.process.computer.SparkGraphComputer
    
    gremlin.hadoop.graphReader=com.microsoft.azure.documentdb.spark.gremlin.DocumentDBInputRDD
    gremlin.hadoop.graphWriter=com.microsoft.azure.documentdb.spark.gremlin.DocumentDBOutputRDD
    
    ####################################
    # SparkGraphComputer Configuration #
    ####################################
    spark.master=yarn
    spark.executor.memory=3g
    spark.executor.instances=6
    spark.serializer=org.apache.spark.serializer.KryoSerializer
    spark.kryo.registrator=org.apache.tinkerpop.gremlin.spark.structure.io.gryo.GryoRegistrator
    gremlin.spark.persistContext=true
    
    # Classpath for the driver and executors
    spark.driver.extraClassPath=/usr/hdp/current/spark2-client/jars/*:/home/sshuser/azure-documentdb-spark/*
    spark.executor.extraClassPath=/usr/hdp/current/spark2-client/jars/*:/home/sshuser/azure-documentdb-spark/*
    
    ######################################
    # DocumentDB Spark connector         #
    ######################################
    spark.documentdb.connectionMode=Gateway
    spark.documentdb.schema_samplingratio=1.0
    spark.documentdb.Endpoint=https://FILLIN.documents.azure.com:443/
    spark.documentdb.Masterkey=FILLIN
    spark.documentdb.Database=FILLIN
    spark.documentdb.Collection=FILLIN
    spark.documentdb.preferredRegions=FILLIN
    
  2. Aggiornare spark.driver.extraClassPath e spark.executor.extraClassPath in modo da includere la directory dei file JAR distribuiti nel passaggio precedente, in questo caso /home/sshuser/azure-documentdb-spark/*.Update the spark.driver.extraClassPath and spark.executor.extraClassPath to include the directory of the jars that you distributed in the previous step, in this case /home/sshuser/azure-documentdb-spark/*.

  3. Specificare i dettagli seguenti per Azure Cosmos DB:Provide the following details for Azure Cosmos DB:

    spark.documentdb.Endpoint=https://FILLIN.documents.azure.com:443/
    spark.documentdb.Masterkey=FILLIN
    spark.documentdb.Database=FILLIN
    spark.documentdb.Collection=FILLIN
    # Optional
    #spark.documentdb.preferredRegions=West\ US;West\ US\ 2
    

Caricare il grafo TinkerPop e salvarlo in Azure Cosmos DBLoad the TinkerPop graph, and save it to Azure Cosmos DB

Per illustrare come è possibile salvare in modo permanente un grafo in Azure Cosmos DB, si usa come esempio il grafo modern predefinito di TinkerPop.To demonstrate how to persist a graph into Azure Cosmos DB, this example uses the TinkerPop predefined TinkerPop modern graph. Il grafo è stato archiviato in formato Kryo ed è disponibile nel repository TinkerPop.The graph is stored in Kryo format, and it's provided in the TinkerPop repository.

  1. Dato che si esegue Gremlin in modalità YARN, è necessario rendere disponibili i dati del grafo nel file system Hadoop.Because you are running Gremlin in YARN mode, you must make the graph data available in the Hadoop file system. Usare i comandi seguenti per creare una directory e copiare al suo interno il file del grafo locale.Use the following commands to make a directory and copy the local graph file into it.

    $ tinkerpop:
    hadoop fs -mkdir /graphData
    hadoop fs -copyFromLocal ~/tinkerpop/data/tinkerpop-modern.kryo /graphData/tinkerpop-modern.kryo
    
  2. Aggiornare temporaneamente il file gremlin-spark.properties in modo da usare GryoInputFormat per la lettura del grafo.Temporarily update the gremlin-spark.properties file to use GryoInputFormat to read the graph. Indicare anche inputLocation come directory creata, come illustrato di seguito:Also indicate inputLocation as the directory you create, as in the following:

    gremlin.hadoop.graphReader=org.apache.tinkerpop.gremlin.hadoop.structure.io.gryo.GryoInputFormat
    gremlin.hadoop.inputLocation=/graphData/tinkerpop-modern.kryo
    
  3. Avviare la console Gremlin e creare questi passaggi di calcolo per salvare in modo permanente i dati nella raccolta Azure Cosmos DB configurata:Start Gremlin Console, and then create the following computation steps to persist data to the configured Azure Cosmos DB collection:

    a.a. Creare il grafo: graph = GraphFactory.open("conf/hadoop/gremlin-spark.properties").Create the graph graph = GraphFactory.open("conf/hadoop/gremlin-spark.properties").

    b.b. Usare SparkGraphComputer per la scrittura graph.compute(SparkGraphComputer.class).result(GraphComputer.ResultGraph.NEW).persist(GraphComputer.Persist.EDGES).program(TraversalVertexProgram.build().traversal(graph.traversal().withComputer(Computer.compute(SparkGraphComputer.class)),"gremlin-groovy","g.V()").create(graph)).submit().get().Use SparkGraphComputer for writing graph.compute(SparkGraphComputer.class).result(GraphComputer.ResultGraph.NEW).persist(GraphComputer.Persist.EDGES).program(TraversalVertexProgram.build().traversal(graph.traversal().withComputer(Computer.compute(SparkGraphComputer.class)),"gremlin-groovy","g.V()").create(graph)).submit().get().

    gremlin> graph = GraphFactory.open("conf/hadoop/gremlin-spark.properties")
    ==>hadoopgraph[gryoinputformat->documentdboutputrdd]
    gremlin> hg = graph.
                compute(SparkGraphComputer.class).
                result(GraphComputer.ResultGraph.NEW).
                persist(GraphComputer.Persist.EDGES).
                program(TraversalVertexProgram.build().
                    traversal(graph.traversal().withComputer(Computer.compute(SparkGraphComputer.class)), "gremlin-groovy", "g.V()").
                    create(graph)).
                submit().
                get() 
    ==>result[hadoopgraph[documentdbinputrdd->documentdboutputrdd],memory[size:1]]
    
  4. In Esplora dati è possibile verificare che i dati siano stati salvati in modo permanente in Azure Cosmos DB.From Data Explorer, you can verify that the data has been persisted to Azure Cosmos DB.

Caricare il grafo da Azure Cosmos DB ed eseguire query Gremlin.Load the graph from Azure Cosmos DB, and run Gremlin queries

  1. Per caricare il grafo, modificare gremlin-spark.properties per impostare graphReader su DocumentDBInputRDD:To load the graph, edit gremlin-spark.properties to set graphReader to DocumentDBInputRDD:

    gremlin.hadoop.graphReader=com.microsoft.azure.documentdb.spark.gremlin.DocumentDBInputRDD
    
  2. Caricare il grafo, attraversare i dati ed eseguire query Gremlin seguendo questa procedura:Load the graph, traverse the data, and run Gremlin queries with it by doing the following:

    a.a. Avviare la console Gremlin bin/gremlin.sh.Start the Gremlin Console bin/gremlin.sh.

    b.b. Creare il grafo con la configurazione graph = GraphFactory.open('conf/hadoop/gremlin-spark.properties').Create the graph with the configuration graph = GraphFactory.open('conf/hadoop/gremlin-spark.properties').

    c.c. Creare un attraversamento del grafo con SparkGraphComputer g = graph.traversal().withComputer(SparkGraphComputer).Create a graph traversal with SparkGraphComputer g = graph.traversal().withComputer(SparkGraphComputer).

    d.d. Eseguire le query Gremlin seguenti sul grafo:Run the following Gremlin graph queries:

    gremlin> graph = GraphFactory.open("conf/hadoop/gremlin-spark.properties")
    ==>hadoopgraph[documentdbinputrdd->documentdboutputrdd]
    gremlin> g = graph.traversal().withComputer(SparkGraphComputer)
    ==>graphtraversalsource[hadoopgraph[documentdbinputrdd->documentdboutputrdd], sparkgraphcomputer]
    gremlin> g.V().count()
    ==>6
    gremlin> g.E().count()
    ==>6
    gremlin> g.V(1).out().values('name')
    ==>josh
    ==>vadas
    ==>lop
    gremlin> g.V().hasLabel('person').coalesce(values('nickname'), values('name'))
    ==>josh
    ==>peter
    ==>vadas
    ==>marko
    gremlin> g.V().hasLabel('person').
            choose(values('name')).
                option('marko', values('age')).
                option('josh', values('name')).
                option('vadas', valueMap()).
                option('peter', label())
    ==>josh
    ==>person
    ==>[name:[vadas],age:[27]]
    ==>29
    

Nota

Per visualizzare una registrazione più dettagliata, impostare un livello di log più dettagliato in conf/log4j-console.properties.To see more detailed logging, set the log level in conf/log4j-console.properties to a more verbose level.

Passaggi successiviNext steps

In questa guida introduttiva si è appreso come usare i grafi combinando Azure Cosmos DB e Spark.In this quick-start article, you've learned how to work with graphs by combining Azure Cosmos DB and Spark.