Eseguire JanusGraph su GKE con Bigtable

I database di grafici possono aiutarti a scoprire insight modellando le entità dati e le relazioni tra loro. JanusGraph è un database di grafici che supporta grandi quantità di dati. Questo tutorial mostra come eseguire JanusGraph su Google Cloud con Google Kubernetes Engine come piattaforma di orchestrazione e Bigtable come backend di archiviazione. Il tutorial è rivolto ad architect, amministratori di database e professionisti DevOps interessati a eseguire il database dei grafici JanusGraph su Google Cloud utilizzando un database gestito come backend di archiviazione. Presuppone che tu abbia familiarità con Google Kubernetes Engine (GKE), i pod di Kubernetes, i grafici Helm, Bigtable ed Elasticsearch. Non è richiesta la conoscenza del framework di graphic computing Apache TinkerPop e della macchina e del linguaggio di attraversamento dei grafici Gremlin, ma queste conoscenze sono necessarie per utilizzare Janusgraph oltre agli esempi forniti in questo tutorial.

Panoramica

Nella terminologia dei grafici, le entità sono chiamate nodi o vertici, mentre le relazioni sono chiamate bordi. In JanusGraph, sia ai vertici che ai bordi possono essere associati ulteriori dati resi disponibili tramite le proprietà.

Esempio di grafico delle proprietà.

L'illustrazione precedente è un esempio di grafico di proprietà.

I database dei grafici consentono di creare modelli di vari domini e attività:

  • Social network
  • Transazioni finanziarie (per l'analisi delle frodi)
  • Reti di sistema fisiche o virtuali

Quando crei database di grafici, a volte crei milioni o persino miliardi di vertici e bordi. Quando utilizzi JanusGraph con Bigtable come livello di archiviazione sottostante, puoi eseguire query rapide (note come attraversamenti grafici) e scalare il livello di archiviazione in modo indipendente in base alle dimensioni e alla velocità effettiva necessarie. JanusGraph utilizza anche un backend di indicizzazione modulare per fornire l'indicizzazione a testo intero per le proprietà di vertice e bordo. In questo tutorial eseguirai il deployment di un'infrastruttura JanusGraph scalabile su GKE. Utilizzi Elasticsearch come backend di indicizzazione in esecuzione nei pod in uno StatefulSet e Bigtable come backend di archiviazione. Al termine, puoi attraversare le relazioni esistenti nei dati del grafico. Il seguente diagramma mostra come questi elementi si integrano tra loro.

Deployment di JanusGraph con Bigtable su GKE.

Il diagramma di esecuzione mostra il deployment di JanusGraph su GKE con Elasticsearch andBigtable.

Dati JanusGraph in Bigtable

I dati dei grafici vengono archiviati da JanusGraph come elenco adiacente. Ogni riga rappresenta un vertice, eventuali vertici (spigoli) adiacenti e metadati di proprietà relativi a vertici e bordi. La chiave di riga è l'identificatore univoco del vertice. Ogni relazione tra il vertice e un altro vertice e tutte le proprietà che definiscono in seguito la relazione vengono memorizzate come bordo o colonna delle proprietà del bordo. Sia il qualificatore di colonna sia i dati dei valori di colonna archiviano i dati che definiscono il perimetro, in conformità con le best practice di Bigtable. Ogni proprietà del vertice viene archiviata come colonna separata, sempre utilizzando sia il qualificatore di colonna sia il valore della colonna per definire la proprietà.

Il seguente diagramma mostra questa struttura di archiviazione.

Struttura di archiviazione dell'elenco di adeguamento JanusGraph.

Il diagramma mostra la struttura di archiviazione logica per un piccolo frammento di grafico con dettagli logici per due righe di vertici. Nel diagramma, le due righe di esempio rappresentano due vertici. Il primo vertice è etichettato con una singola proprietà di vertice ed è correlato ad altri due vertici con due bordi separati. Il secondo vertice contiene colonne contenenti due proprietà e un bordo.

La seguente illustrazione del modello dei dati logico del bordo del vertice fornisce alcuni dettagli sui qualificatori di colonna e sui valori di una colonna di bordo o di proprietà del bordo.

Colonna della proprietà JanusGraph Edge e Edge.

Per ogni vertice adiacente, una colonna memorizza i metadati relativi a quel bordo. Il qualificatore di colonna contiene metadati sulla relazione dello spigolo e sulla sua direzione, nonché un puntatore al vertice adiacente. Il valore della colonna contiene l'etichetta del bordo ed eventuali proprietà del bordo aggiuntive. Poiché gli attraversamenti possono essere seguiti in entrambe le direzioni, gli angoli vengono archiviati due volte, una per ciascuna estremità della relazione perimetrale. L'archiviazione periferica bidirezionale aumenta notevolmente le prestazioni dell'attraversamento, ma offre alcuni compromessi dovuti alla ridondanza dello spazio di archiviazione aggiuntivo e alle mutazioni non atomiche dei bordi.

Il seguente diagramma è il modello logico dei dati di una colonna della proprietà del vertice.

Valori della colonna JanusGraph per una colonna di proprietà.

L'illustrazione precedente fornisce dettagli sui qualificatori di colonna e sui valori di una colonna perimetrale.

Ogni proprietà del vertice viene archiviata come colonna separata. Il qualificatore di colonna è un identificatore univoco della chiave di proprietà. Il valore della colonna contiene sia un identificatore della proprietà sia il valore della proprietà.

JanusGraph si basa anche sull'ordine lessicografico di righe e qualificatori di colonna di Bigtable per migliorare le prestazioni delle query.

Obiettivi

  • Crea un'istanza Bigtable.
  • Crea un cluster GKE.
  • Installa Helm.
  • Utilizza un grafico Helm per il deployment di JanusGraph ed Elasticsearch.
  • Utilizza la console Gremlin e connettiti a JanusGraph.
  • Carica ed esegui query sui dati di esempio.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prerequisiti

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. Abilita le API Bigtable, Compute Engine e GKE .

    Abilita le API

    5.

  5. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  7. Abilita le API Bigtable, Compute Engine e GKE .

    Abilita le API

    8.

prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per inserire i comandi. Cloud Shell ti dà accesso alla riga di comando nella console Google Cloud e include Google Cloud CLI e altri strumenti di cui hai bisogno per sviluppare in Google Cloud. Cloud Shell è visualizzato come una finestra in fondo alla console Google Cloud. L'inizializzazione può richiedere diversi minuti, ma la finestra viene visualizzata immediatamente.

  1. Nella console Google Cloud, attiva Cloud Shell.

    Attiva Cloud Shell

  2. In Cloud Shell, imposta le variabili di ambiente per la zona Compute Engine in cui creerai il cluster Bigtable e il cluster GKE e il nome, il tipo di nodo e la versione per il tuo cluster GKE:

    export PROJECT_ID=PROJECT_ID
export GCP_ZONE=REGION
export GKE_CLUSTER_NAME=GKE_CLUSTER_NAME
export GKE_NODE_TYPE=n1-standard-4
export GKE_VERSION=1.20

    Sostituisci quanto segue:

    • PROJECT_ID con l'identificatore del progetto.
    • REGION con la zona in cui verranno creati il cluster Bigtable e il cluster GKE.
    • GKE_CLUSTER_NAME con il nome del tuo cluster GKE.

    Il comando dovrebbe essere simile al seguente esempio:

    export PROJECT_ID=bt-janusgraph-project-id
export GCP_ZONE=us-central1-f
export GKE_CLUSTER_NAME=janusgraph-gke
export GKE_NODE_TYPE=n1-standard-4
export GKE_VERSION=1.20

  3. Crea un cluster GKE in cui verrà eseguito il deployment di JanusGraph:

    gcloud container clusters create ${GKE_CLUSTER_NAME} \
    --zone=${GCP_ZONE} \
    --cluster-version=${GKE_VERSION} \
    --machine-type ${GKE_NODE_TYPE} \
    --scopes "https://www.googleapis.com/auth/cloud-platform"

Crea un'istanza Bigtable

Per il backend di archiviazione JanusGraph, questo tutorial utilizza Bigtable, che può scalare rapidamente in base alle tue esigenze. Questo tutorial utilizza un cluster a nodo singolo, economico e sufficiente per il tutorial. Puoi avviare i tuoi progetti con un cluster più piccolo e poi spostarli in un cluster più grande quando vuoi lavorare con i dati di produzione. La documentazione di Bigtable include una discussione dettagliata su prestazioni e scalabilità per aiutarti a scegliere una dimensione del cluster per il tuo lavoro.

  1. In Cloud Shell, imposta la variabile di ambiente per l'identificatore dell'istanza Bigtable:

    export BIGTABLE_INSTANCE_ID=BIGTABLE_INSTANCE_ID

    Sostituisci BIGTABLE_INSTANCE_ID con l'identificatore dell'istanza Bigtable.

  2. Crea l'istanza Bigtable:

    gcloud bigtable instances create ${BIGTABLE_INSTANCE_ID} \
    --cluster-config=id=${BIGTABLE_INSTANCE_ID}-${GCP_ZONE},zone=${GCP_ZONE},nodes=1 \
    --display-name=${BIGTABLE_INSTANCE_ID}-${GCP_ZONE}

Installa e configura Helm

Puoi utilizzare Helm per eseguire il deployment di applicazioni nel tuo cluster Kubernetes. In questo tutorial utilizzerai Helm per eseguire il deployment dei servizi JanusGraph ed Elasticsearch sul tuo cluster GKE.

  1. In Cloud Shell, installa Helm:

    curl -fsSL -o get_helm.sh \
    https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3
chmod 700 get_helm.sh
DESIRED_VERSION=v3.5.0 ./get_helm.sh

  2. Aggiungi il repository dei grafici elastic, in modo da poter trovare la dipendenza del grafico Elasticsearch durante il deployment del grafico JanusGraph:

    helm repo add elastic https://helm.elastic.co

    Questo repository di grafici è ospitato da Elastic, i creatori di Elasticsearch.

Utilizza Helm per installare JanusGraph ed Elasticsearch

In questa sezione utilizzerai un grafico Helm per eseguire il deployment di JanusGraph ed Elasticsearch nel tuo cluster Kubernetes.

Il grafico Helm viene estratto da GitHub. Il deployment incluso nel repository dei grafici Helm esegue il deployment di un set di tre pod JanusGraph dietro un servizio che avvierà un bilanciatore del carico delle applicazioni interno. Quando i pod sono in esecuzione, i probe di avvio e di attività effettuano richieste HTTP per eseguire i controlli di integrità sul server JanusGraph in ciascun pod. Inoltre, il grafico include un grafico delle dipendenze fornito da Elastic che esegue il deployment di tre pod Elasticsearch in uno StatefulSet.

  1. In Cloud Shell, imposta le variabili di ambiente per i nomi Helm e Janus Graphaph:

    export HELM_REPO=bigtable-janusgraph-helm
export JANUSGRAPH_VERSION=0.5.3
export HELM_CHART_RELEASE_VERSION=1
export HELM_CHART_RELEASE_TAG=${JANUSGRAPH_VERSION}-${HELM_CHART_RELEASE_VERSION}
export HELM_CHART_RELEASE_TAG_HASH=f8b271a4854d4a553dd5e9ba014d077fb098d9ab
export HELM_CHART_NAME=janusgraph-bigtable

  2. Esegui il pull del grafico Helm da GitHub:

    git clone https://github.com/GoogleCloudPlatform/${HELM_REPO} \
   --branch ${HELM_CHART_RELEASE_TAG}

  3. Vai alla directory del grafico Helm:

    cd ${HELM_REPO}

  4. Per motivi di sicurezza, esegui la verifica utilizzando l'hash di commit:

    HEAD_COMMIT_HASH=$(git rev-parse --verify HEAD)
if [ _${HEAD_COMMIT_HASH} == _${HELM_CHART_RELEASE_TAG_HASH} ]
then
    echo "Commit hash verified"
fi

    Se l'output non è simile al seguente, non procedere perché l'integrità del tag clonato non è stata verificata.

    Commit hash verified

  5. Aggiorna le dipendenze del grafico:

    helm dep update

  6. Vai alla directory padre:

    cd ..

  7. Imposta le variabili di ambiente per i nomi delle entità Helm e JanusGraph:

    export HELM_RELEASE_NAME=janusgraph-bigtable-elastic
export ELASTICSEARCH_CLUSTER_NAME=${HELM_RELEASE_NAME}-elasticsearch
export BIGTABLE_JANUSGRAPH_TABLE=janusgraph-table

  8. Crea un file values.yaml, che fornisce a Helm le proprietà di configurazione da utilizzare per il deployment del grafico JanusGraph:

    cat > values.yaml << EOF

image:
  repository: docker.io/janusgraph/janusgraph
  tag: 0.5.3
  pullPolicy: IfNotPresent

replicaCount: 3

service:
  type: LoadBalancer
  port: 8182
  serviceAnnotations:
    networking.gke.io/load-balancer-type: "Internal"

elasticsearch:
  deploy: true
  clusterName: ${ELASTICSEARCH_CLUSTER_NAME}

properties:
  storage.backend: hbase
  storage.directory: null
  storage.hbase.ext.google.bigtable.instance.id: ${BIGTABLE_INSTANCE_ID}
  storage.hbase.ext.google.bigtable.project.id: ${PROJECT_ID}
  storage.hbase.ext.hbase.client.connection.impl: com.google.cloud.bigtable.hbase2_x.BigtableConnection
  storage.hbase.short-cf-names: true
  storage.hbase.table: ${BIGTABLE_JANUSGRAPH_TABLE}
  index.search.backend: elasticsearch
  index.search.hostname: ${ELASTICSEARCH_CLUSTER_NAME}-master
  index.search.directory: null
  index.search.elasticsearch.health-request-timeout: 90s
  cache.db-cache: true
  cache.db-cache-clean-wait: 20
  cache.db-cache-time: 180000
  cache.db-cache-size: 0.5
  cluster.max-partitions: 1024
  graph.replace-instance-if-exists: true

persistence:
  enabled: false

debugLevel: INFO
EOF

  9. Esegui il deployment del grafico Helm JanusGraph utilizzando il file values.yaml che hai creato:

    helm upgrade --install \
             --wait \
              --timeout 600s \
              ${HELM_RELEASE_NAME} \
              ./${HELM_REPO} \
              -f values.yaml

    Il processo di installazione attende che tutte le risorse siano pronte prima di essere completato. Questa procedura potrebbe richiedere diversi minuti.

Verificare il deployment di JanusGraph

Al termine del processo di installazione di Helm, viene visualizzata una sezione NOTES che descrive un'esperienza iniziale. Puoi seguire i passaggi descritti nella sezione NOTES per verificare che l'ambiente Janus Graph funzioni.

  1. In Cloud Shell, verifica che i componenti del grafico Helm di cui è stato eseguito il deployment in GKE:

    1. Controlla il deployment di JanusGraph:

      kubectl get deployments

      Se il deployment ha esito positivo, l'output è il seguente:

      NAME                          READY   UP-TO-DATE   AVAILABLE   AGE
janusgraph-bigtable-elastic   3/3     3            3           3m28s

    2. Controlla l'Elasticsearch StatefulSet:

      kubectl get statefulsets

      Se tutto funziona, l'output è il seguente:

      NAME                                               READY   AGE
janusgraph-bigtable-elastic-elasticsearch-master   3/3     4m13s

  2. Imposta una variabile di ambiente sul nome di un pod Kubernetes su cui è in esecuzione il server JanusGraph Gremlin. L'etichetta app del pod su cui è in esecuzione il server Gremlin deriva dal nome del grafico Helm definito nel file Chart.yaml.

    export APP_LABEL_FROM_CHART_NAME=${HELM_CHART_NAME}
export POD_NAME=$(kubectl get pods \
                     --namespace default \
                     -l "app=${APP_LABEL_FROM_CHART_NAME}, \
                         release=${HELM_RELEASE_NAME}" \
                     -o jsonpath="{.items[0].metadata.name}")

  3. Connettiti al pod ed esegui la console Gremlin, una shell di Read Eval Print Loop (REPL). Il nome del container deriva anche dal nome del grafico Helm in Chart.yaml.

    export GREMLIN_CONTAINER=${HELM_CHART_NAME}
kubectl exec \
        -c ${GREMLIN_CONTAINER} \
        -it $POD_NAME \
        -- /opt/janusgraph/bin/gremlin.sh

  4. Nella console di Gremlin, connettiti al server Apache TinkerPop:

    1. Avvia la sessione:

      :remote connect tinkerpop.server conf/remote.yaml session

      L'output è simile al seguente:

      ==>Configured localhost/127.0.0.1:8182-[b08972f2-a2aa-4312-8018-bcd11bc9812c]

    2. Connettiti al server:

      :remote console

      L'output è simile al seguente:

      ==>All scripts will now be sent to Gremlin Server - [localhost/127.0.0.1:8182]-[b08972f2-a2aa-4312-8018-bcd11bc9812c] - type ':remote console' to return to local mode>

  5. Nella console di Gremlin, verifica che il server Gremlin funzioni correttamente esaminando la variabile graph che rappresenta l'istanza del grafico:

    graph

    L'output indica che il server JanusGraph è in esecuzione con un database compatibile con HBase, in questo caso Bigtable, come backend di archiviazione.

    ==>standardjanusgraph[hbase:[127.0.0.1]]

  6. In Gremlin, crea due vertici

    v1 = graph.addVertex(label, 'hello')
v2 = graph.addVertex(label, 'world')

    Se l'output della console è simile al seguente, indica che i due vertici sono stati aggiunti:

    ==>v[4344]
==>v[4152]

  7. Crea uno spigolo che collega i due vertici:

    v1.addEdge('followedBy', v2)

    Se l'output della console è simile al seguente, indica che è stato aggiunto il bordo tra i due vertici:

    ==>e[17j-3co-4fmd-oe054][4344-followedBy->4152]

  8. Esegui il commit della transazione:

    graph.tx().commit()

    Se l'output della console è null, significa che le operazioni sono state immesse:

    ==>null

    Il seguente diagramma illustra il grafico creato dai comandi.

    Esempio di vertici e bordi JanusGraph.

    Il vertice etichettato hello è collegato da un bordo diretto etichettato followedBy al vertice denominato world.

  9. Esegui una query Gremlin per vedere qual è l'etichetta per il vertice che segue un bordo con l'etichetta followedBy a partire dal vertice etichettato come hello:

    g.V().has(label, 'hello').out('followedBy').label()

    La sintassi della query è spiegata nella prossima sezione. Per il momento, visualizzi la parola world come output della query:

    ==>world

Carica ed esegui query su un set di dati di esempio

Ora che hai eseguito il deployment di JanusGraph e puoi connetterti utilizzando Gremlin, puoi iniziare a caricare ed eseguire query sui tuoi dati. Per vedere che aspetto ha questo processo, carica il set di dati campione fornito con Janus Graph, il Grafico degli dei, che mostra le divinità mitologiche del pantheon romano e le relative proprietà relative alla posizione.

  1. In Gremlin, carica il grafico che hai creato in precedenza:

    GraphOfTheGodsFactory.load(graph)

    L'output è il seguente:

    ==>null

  2. Esegui una query di attraversamento grafico che trovi tutti i fratelli di Giove:

    g.V().has('name', 'jupiter').out('brother').values('name')

    La tabella seguente illustra i passaggi attraversati dalla query.

    Passaggio di attraversamento Spiegazione
    g.V() Inizia con la raccolta di vertici.
    has('name', 'jupiter') Trovane uno con la proprietà name con il valore jupiter.
    out('brother') Da qui, segui tutti i bordi con l'etichetta brother.
    values('name') Per i vertici a cui seguono questi bordi, ottieni la proprietà name.
    L'output è il seguente:

    ==>neptune
==>pluto

    Per acquisire maggiore familiarità con le query di attraversamento possibili in questo set di dati Graph of the Gods, prova altre query di esempio della documentazione JanusGraph.

Verificare che i dati siano archiviati in Bigtable

Ora che hai creato alcuni dati di esempio nel cluster JanusGraph, puoi verificare che Bigtable sia stato utilizzato come backend di archiviazione.

  1. Chiudi la console di Gremlin:

    :q

  2. In Cloud Shell, verifica che i dati siano stati resi persistenti nella tabella janusgraph in Bigtable:

    cbt -project=${PROJECT_ID} \
    -instance=${BIGTABLE_INSTANCE_ID} \
     count ${BIGTABLE_JANUSGRAPH_TABLE}

    L'output è simile al seguente.

    2021/03/02 02:32:19 -creds flag unset, will use gcloud credential
101

    Il valore 101 nell'output rappresenta il numero di righe in janusgraph table e potrebbe essere diverso per te.

Verifica la creazione dell'indice di ricerca in Elasticsearch

  1. In Cloud Shell, imposta le variabili per l'indice e il nome del pod Elasticsearch:

    export ELASTICSEARCH_POD_ORDINAL=0
export ELASTICSEARCH_POD_NAME_ROOT=${ELASTICSEARCH_CLUSTER_NAME}-master
export ELASTICSEARCH_POD=${ELASTICSEARCH_POD_NAME_ROOT}-0

    I nomi dei pod Elasticsearch sono definiti dalle dipendenze Elasticsearch Helm. I nomi dei pod sono composti dal nome del cluster fornito nel file values.yaml che hai creato, la parola master e da un numero ordinale indicizzato zero, tutti separati da trattini. Per questo passaggio, sceglierai il primo pod, rappresentato da zero (0).

  2. Utilizza l'API REST Elasticsearch Aliases per esaminare gli indici:

    kubectl exec \
        -c elasticsearch \
        -it ${ELASTICSEARCH_POD} \
        --  \
        curl -XGET "127.0.0.1:9200/_aliases?pretty=true";

    L'output mostra due indici, janusgraph_vertices e janusgraph_edges, che sono stati creati da JanusGraph per fornire ricerche efficienti utilizzando le proprietà di vertice e bordo:

    {
  "janusgraph_vertices" : {
    "aliases" : {
      "janusgraph" : { }
    }
  },
  "janusgraph_edges" : {
    "aliases" : {
      "janusgraph" : { }
    }
  }
}

  3. Esegui una query sui valori di uno degli indici utilizzando l'API REST Elasticsearch Search:

    kubectl exec \
       -c elasticsearch \
       -it ${ELASTICSEARCH_POD} \
       --  \
       curl -XGET "127.0.0.1:9200/janusgraph_edges/_search?pretty=true&q=*";

    I risultati di ricerca mostrano che sono presenti voci negli indici creati da JanusGraph. L'output visualizzato è simile ai seguenti risultati troncati, che mostrano la presenza di voci nell'indice janusgraph_edges.

    {
 "took" : 94,
 "timed_out" : false,
 "_shards" : {
   "total" : 1,
   "successful" : 1,
   "skipped" : 0,
   "failed" : 0
 },
 "hits" : {
   "total" : {
     "value" : 6,
     "relation" : "eq"
   },
   "max_score" : 1.0,
   "hits" : [
     {
       "_index" : "janusgraph_edges",
       "_type" : "_doc",
       "_id" : "6bvp-5ovc-b2t-2yko",
       "_score" : 1.0,
       "_source" : {
         "reason" : "loves waves"
       }
     },
     {
…

Elimina il progetto

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi