Menjalankan JanusGraph di GKE dengan Bigtable

Database grafik dapat membantu Anda menemukan insight dengan membuat model entity data dan hubungan di antara entity tersebut. JanusGraph adalah database grafik yang mendukung penggunaan data dalam jumlah besar. Tutorial ini menunjukkan cara menjalankan JanusGraph di Google Cloud dengan Google Kubernetes Engine sebagai platform orkestrasi dan Bigtable sebagai backend penyimpanan. Tutorial ini ditujukan bagi arsitek sistem, administrator database, dan profesional DevOps yang tertarik untuk menjalankan database grafik JanusGraph di Google Cloud menggunakan database terkelola sebagai backend penyimpanan. Dokumen ini mengasumsikan bahwa Anda memahami Google Kubernetes Engine (GKE), Pod Kubernetes, diagram Helm, Bigtable, dan Elasticsearch. Pengetahuan tentang framework komputasi grafik Apache TinkerPop dan mesin serta bahasa traversal grafik Gremlin tidak diperlukan, tetapi pengetahuan tersebut diperlukan untuk menggunakan Janusgraph di luar contoh yang diberikan dalam tutorial ini.

Ringkasan

Dalam terminologi grafik, entity dikenal sebagai node atau vertex dan hubungan dikenal sebagai edge. Di JanusGraph, vertex dan edge dapat memiliki data terkait tambahan yang tersedia melalui properti.

Ilustrasi sebelumnya adalah contoh grafik properti.

Database grafik membantu Anda membuat model berbagai domain dan aktivitas:

• Jaringan sosial
• Transaksi keuangan (untuk analisis penipuan)
• Jaringan sistem fisik atau virtual

Saat membuat database grafik, Anda terkadang membuat jutaan atau bahkan miliaran vertikal dan tepi. Saat menggunakan JanusGraph dengan Bigtable sebagai lapisan penyimpanan dasar, Anda dapat menjalankan kueri cepat (dikenal sebagai traversal grafik) dan menskalakan lapisan penyimpanan secara independen sesuai dengan ukuran dan throughput yang Anda butuhkan. JanusGraph juga menggunakan backend pengindeksan plug-in untuk menyediakan pengindeksan teks lengkap untuk properti vertex dan edge. Dalam tutorial ini, Anda akan men-deploy infrastruktur JanusGraph yang skalabel di GKE. Anda menggunakan Elasticsearch sebagai backend pengindeksan yang berjalan di Pod dalam StatefulSet, dan Anda menggunakan Bigtable sebagai backend penyimpanan. Setelah selesai, Anda dapat menjelajahi hubungan yang ada dalam data grafik. Diagram berikut menunjukkan kecocokan elemen-elemen ini.

Diagram sebelumnya menunjukkan deployment JanusGraph di GKE dengan Elasticsearch dan Bigtable.

Data JanusGraph di Bigtable

Data grafik disimpan oleh JanusGraph sebagai daftar adjacensi. Setiap baris mewakili vertikal, vertikal (tepi) yang berdekatan, dan metadata properti tentang vertex dan tepi. Kunci baris adalah ID unik untuk vertex. Setiap hubungan antara vertex dan vertex lain serta properti apa pun yang menentukan hubungan lebih lanjut disimpan sebagai kolom tepi atau properti tepi. Penentu kolom dan nilai kolom menyimpan data yang menentukan edge, sesuai dengan praktik terbaik Bigtable. Setiap properti vertex disimpan sebagai kolom terpisah, lagi-lagi menggunakan penentu kolom dan nilai kolom untuk menentukan properti.

Diagram berikut menunjukkan struktur penyimpanan ini.

Diagram menunjukkan struktur penyimpanan logis untuk fragmen grafik kecil dengan detail logis untuk dua baris vertex. Dalam diagram, dua contoh baris mewakili dua vertex. Verteks pertama diberi label dengan satu properti verteks dan terkait dengan dua verteks lain oleh dua sisi yang terpisah. Vertix kedua berisi kolom yang berisi dua properti dan satu tepi.

Ilustrasi model data logis tepi vertex berikut memberikan beberapa detail tentang penentu kolom dan nilai untuk kolom tepi atau properti tepi.

Untuk setiap vertex yang berdekatan, kolom menyimpan metadata tentang tepi tersebut. Penentu kolom berisi metadata tentang hubungan tepi dan tentang arah tepi, serta pointer ke vertex yang berdekatan. Nilai kolom berisi label tepi dan properti tepi tambahan. Karena traversal dapat diikuti dalam kedua arah, tepi disimpan dua kali, satu kali untuk setiap ujung hubungan tepi. Penyimpanan tepi dua arah secara signifikan meningkatkan performa traversal, tetapi disertai dengan beberapa kompromi karena redundansi ruang penyimpanan tambahan dan mutasi tepi non-atomik.

Diagram berikut adalah model data logis dari kolom properti vertex.

Ilustrasi sebelumnya memberikan detail tentang penentu kolom dan nilai untuk kolom tepi.

Setiap properti vertex disimpan sebagai kolom terpisah. Penentu kolom adalah ID unik untuk kunci properti. Nilai kolom berisi ID untuk properti dan nilai properti.

JanusGraph juga mengandalkan pengurutan leksikografis baris dan penentu kolom Bigtable untuk meningkatkan performa kueri.

Tujuan

• Buat instance Bigtable.
• Buat cluster GKE.
• Instal Helm.
• Gunakan diagram Helm untuk men-deploy JanusGraph dan Elasticsearch.
• Gunakan konsol Gremlin dan hubungkan ke JanusGraph.
• Muat, lalu buat kueri data sampel.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

• Google Kubernetes Engine (GKE)
• Compute Engine VMs are provisioned by GKE
• Bigtable

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Prasyarat

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

3. Make sure that billing is enabled for your Google Cloud project.

4. Aktifkan API Bigtable, Compute Engine, and GKE .

   Mengaktifkan API

5. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

6. Make sure that billing is enabled for your Google Cloud project.

7. Aktifkan API Bigtable, Compute Engine, and GKE .

   Mengaktifkan API

Menyiapkan lingkungan Anda

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk memasukkan perintah. Cloud Shell memberi Anda akses ke command line di Konsol Google Cloud dan mencakup Google Cloud CLI serta alat lain yang Anda perlukan untuk mengembangkan di Google Cloud. Cloud Shell akan muncul sebagai jendela di bagian bawah konsol Google Cloud. Perlu waktu beberapa menit untuk melakukan inisialisasi, tetapi jendela akan segera muncul.

1. Di konsol Google Cloud, aktifkan Cloud Shell.

   Aktifkan Cloud Shell

2. Di Cloud Shell, tetapkan variabel lingkungan untuk zona Compute Engine tempat Anda akan membuat cluster Bigtable dan cluster GKE serta nama, jenis node, dan versi untuk cluster GKE Anda:

   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
   

   Ganti kode berikut:

   • PROJECT_ID dengan ID project Anda.
   • REGION dengan zona tempat cluster Bigtable dan cluster GKE Anda akan dibuat.
   • GKE_CLUSTER_NAME dengan nama cluster GKE Anda.

   Perintah akan terlihat seperti contoh berikut:

   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. Buat cluster GKE tempat JanusGraph akan di-deploy:

   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"
   

Membuat instance Bigtable

Untuk backend penyimpanan JanusGraph, tutorial ini menggunakan Bigtable, yang dapat diskalakan dengan cepat untuk memenuhi kebutuhan Anda. Tutorial ini menggunakan cluster satu node, yang hemat dan memadai untuk tutorial. Anda dapat memulai project dengan cluster yang lebih kecil, lalu beralih ke cluster yang lebih besar saat siap menggunakan data produksi. Dokumentasi Bigtable berisi diskusi mendetail tentang performa dan penskalaan untuk membantu Anda memilih ukuran cluster untuk pekerjaan Anda sendiri.

1. Di Cloud Shell, tetapkan variabel lingkungan untuk ID instance Bigtable Anda:

   export BIGTABLE_INSTANCE_ID=BIGTABLE_INSTANCE_ID
   

   Ganti BIGTABLE_INSTANCE_ID dengan ID untuk instance Bigtable Anda.

2. Buat instance 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}
   

Menginstal dan mengonfigurasi Helm

Anda menggunakan Helm untuk men-deploy aplikasi ke cluster Kubernetes. Dalam tutorial ini, Anda akan menggunakan Helm untuk men-deploy layanan JanusGraph dan Elasticsearch di cluster GKE.

1. Di Cloud Shell, instal 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. Tambahkan repositori diagram elastic, sehingga dependensi diagram Elasticsearch dapat ditemukan selama deployment diagram JanusGraph:

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

   Repositori diagram ini dihosting oleh Elastic, pembuat Elasticsearch.

Menggunakan Helm untuk menginstal JanusGraph dan Elasticsearch

Di bagian ini, Anda akan menggunakan diagram Helm untuk men-deploy JanusGraph dan Elasticsearch ke cluster Kubernetes.

Diagram Helm diambil dari GitHub. Deployment yang disertakan dalam repositori diagram Helm men-deploy kumpulan tiga Pod JanusGraph di belakang Layanan yang akan memulai Load Balancer Aplikasi internal. Saat Pod berjalan, pemeriksaan startup dan keaktifan membuat permintaan HTTP untuk melakukan pemeriksaan kesehatan pada server JanusGraph di setiap Pod. Selain itu, diagram menyertakan diagram dependensi yang disediakan oleh Elastic yang men-deploy tiga Pod Elasticsearch di StatefulSet.

1. Di Cloud Shell, tetapkan variabel lingkungan untuk nama Helm dan JanusGraph:

   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. Ambil diagram Helm dari GitHub:

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

3. Buka direktori diagram Helm:

   cd ${HELM_REPO}
   

4. Untuk tujuan keamanan, verifikasi menggunakan hash commit:

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

   Jika output tidak terlihat mirip dengan yang berikut ini, jangan lanjutkan karena integritas tag yang di-clone belum diverifikasi.

   Commit hash verified
   

5. Memperbarui dependensi diagram:

   helm dep update
   

6. Buka direktori induk:

   cd ..
   

7. Tetapkan variabel lingkungan untuk nama entitas Helm dan JanusGraph:

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

8. Buat file values.yaml, yang menyediakan properti konfigurasi untuk digunakan saat men-deploy diagram 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. Deploy diagram Helm JanusGraph menggunakan file values.yaml yang Anda buat:

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

   Proses penginstalan menunggu hingga semua resource siap sebelum selesai. Proses ini mungkin memerlukan waktu beberapa menit.

Memverifikasi deployment JanusGraph

Setelah proses penginstalan Helm selesai, proses ini akan menampilkan bagian NOTES yang menjelaskan pengalaman memulai. Anda dapat mengikuti langkah-langkah yang diuraikan di bagian NOTES untuk memverifikasi bahwa lingkungan JanusGraph Anda berfungsi.

1. Di Cloud Shell, pastikan komponen diagram Helm di-deploy ke GKE:

   1. Periksa deployment JanusGraph:

      kubectl get deployments
      

      Jika deployment berhasil, output-nya akan terlihat seperti berikut:

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

   2. Periksa StatefulSet Elasticsearch:

      kubectl get statefulsets
      

      Jika semuanya berfungsi, output-nya adalah sebagai berikut:

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

2. Tetapkan variabel lingkungan ke nama Pod Kubernetes yang menjalankan server Gremlin JanusGraph. Label app untuk Pod yang menjalankan server Gremlin berasal dari nama diagram Helm yang ditentukan dalam 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. Hubungkan ke Pod dan jalankan konsol Gremlin, shell read eval print loop (REPL). Nama penampung juga berasal dari nama diagram Helm di Chart.yaml.

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

4. Di konsol Gremlin, hubungkan ke server Apache TinkerPop:

   1. Mulai sesi:

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

      Outputnya terlihat mirip dengan yang berikut ini:

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

   2. Menghubungkan ke server:

      :remote console
      

      Outputnya terlihat mirip dengan yang berikut ini:

      ==>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. Di konsol Gremlin, pastikan server Gremlin berjalan dengan benar dengan memeriksa variabel graph yang mewakili instance grafik:

   graph
   

   Output menunjukkan bahwa server JanusGraph berjalan dengan database yang kompatibel dengan HBase, dalam hal ini Bigtable, sebagai backend penyimpanan.

   ==>standardjanusgraph[hbase:[127.0.0.1]]
   

6. Di Gremlin, buat dua vertex

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

   Jika output konsol mirip dengan yang berikut ini, artinya dua vertikal telah ditambahkan:

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

7. Buat tepi yang menghubungkan kedua verteks:

   v1.addEdge('followedBy', v2)
   

   Jika output konsol mirip dengan yang berikut ini, ini menunjukkan bahwa sisi antara dua vertex telah ditambahkan:

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

8. Lakukan commit pada transaksi:

   graph.tx().commit()
   

   Jika output konsol adalah null, ini menunjukkan bahwa operasi telah dilakukan:

   ==>null
   

   Diagram berikut menggambarkan grafik yang dibuat oleh perintah.

   

   Vertix berlabel hello terhubung oleh tepi terarah berlabel followedBy ke vertex berlabel world.

9. Buat kueri Gremlin untuk melihat label untuk vertex yang mengikuti tepi berlabel followedBy dari vertex yang berlabel hello:

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

   Sintaksis kueri dijelaskan di bagian berikutnya. Untuk saat ini, Anda akan melihat kata world sebagai output dari kueri:

   ==>world
   

Memuat dan membuat kueri set data contoh

Setelah men-deploy JanusGraph dan dapat terhubung ke JanusGraph menggunakan Gremlin, Anda dapat mulai memuat dan membuat kueri data Anda sendiri. Untuk melihat tampilan proses tersebut, muat set data contoh yang disertakan dalam paket JanusGraph— Graph of the Gods, yang menggambarkan dewa mitologi dari panteon Romawi dan properti lokasinya.

1. Di Gremlin, muat grafik yang Anda buat sebelumnya:

   GraphOfTheGodsFactory.load(graph)
   

   Outputnya adalah sebagai berikut:

   ==>null
   

2. Buat kueri traversal grafik yang menemukan semua saudara Jupiter:

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

   Tabel berikut menjelaskan langkah-langkah yang dilalui kueri.

   Langkah traversal	Penjelasan
   g.V()	Mulai dengan kumpulan vertex.
   has('name', 'jupiter')	Temukan salah satu yang memiliki properti name dengan nilai jupiter.
   out('brother')	Dari sana, ikuti tepi yang berlabel brother.
   values('name')	Untuk vertex tempat tepi tersebut mengarah, dapatkan properti name.

   Outputnya adalah sebagai berikut:

   ==>neptune
   ==>pluto
   

   Untuk lebih memahami kueri traversal yang mungkin dilakukan pada set data Graph of the Gods ini, coba contoh kueri lainnya dari dokumen JanusGraph.

Memverifikasi bahwa data disimpan di Bigtable

Setelah membuat beberapa contoh data di cluster JanusGraph, Anda dapat memverifikasi bahwa Bigtable digunakan sebagai backend penyimpanan.

1. Tutup konsol Gremlin:

   :q
   

2. Di Cloud Shell, pastikan data telah dipertahankan ke tabel janusgraph di Bigtable:

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

   Outputnya mirip dengan yang berikut ini.

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

   Nilai 101 dalam output mewakili jumlah baris di janusgraph table, dan mungkin berbeda untuk Anda.

Memverifikasi pembuatan indeks penelusuran di Elasticsearch

1. Di Cloud Shell, tetapkan variabel untuk indeks dan nama Pod Elasticsearch:

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

   Nama Pod Elasticsearch ditentukan oleh dependensi Helm Elasticsearch. Nama Pod terdiri dari nama cluster seperti yang disediakan dalam file values.yaml yang Anda buat, kata master, dan angka ordinal dengan indeks nol, semuanya dipisahkan dengan tanda hubung. Untuk langkah ini, Anda memilih Pod pertama, yang direpresentasikan sebagai nol (0).

2. Gunakan Elasticsearch Aliases REST API untuk memeriksa indeks:

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

   Output menunjukkan dua indeks, janusgraph_vertices dan janusgraph_edges, telah dibuat oleh JanusGraph untuk memberikan pencarian yang efisien menggunakan properti vertikal dan tepi:

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

3. Buat kueri nilai dari salah satu indeks menggunakan Elasticsearch Search REST API:

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

   Hasil penelusuran menunjukkan bahwa ada entri dalam indeks yang dibuat oleh JanusGraph. Output yang Anda lihat mirip dengan hasil yang terpotong berikut, yang menunjukkan bahwa ada entri dalam indeks 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"
          }
        },
        {
   …
   

Menghapus project

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Perhatian: Menghapus project memiliki efek berikut:

• Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
• Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

1. Di konsol Google Cloud, buka halaman Manage resource.

   Buka Manage resource

2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Langkah selanjutnya

• Baca selengkapnya tentang JanusGraph dan database grafik.
• Pelajari framework komputasi grafik Apache TinkerPop dan jelajahi bahasa traversal grafik Gremlin.
• Pelajari lebih lanjut cara JanusGraph menyimpan data di Bigtable.
• Pelajari kasus penggunaan grafik lebih dalam dengan men-deploy contoh aplikasi JanusGraph.