Menjalankan JanusGraph di GKE dengan Bigtable

Database grafik dapat membantu Anda menemukan insight dengan membuat model entity data Anda dan hubungan di antara mereka. JanusGraph adalah database grafik yang mendukung pemrosesan 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 untuk arsitek sistem, administrator database, dan profesional DevOps yang tertarik untuk menjalankan database grafik JanusGraph di Google Cloud menggunakan database terkelola sebagai backend penyimpanan. Hal ini mengasumsikan bahwa Anda telah memahami Google Kubernetes Engine (GKE), Kubernetes Pods, 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 verteks dan hubungan dikenal sebagai edge. Di JanusGraph, verteks dan tepi dapat memiliki data terkait tambahan yang disediakan melalui properti.

Contoh grafik properti.

Ilustrasi sebelumnya adalah contoh grafik properti.

{i>Database<i} 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, terkadang Anda membuat jutaan atau bahkan miliaran verteks dan tepi. Jika menggunakan JanusGraph dengan Bigtable sebagai lapisan penyimpanan yang mendasarinya, Anda dapat mengeksekusi kueri cepat (dikenal sebagai graph traversal) dan menskalakan lapisan penyimpanan secara independen sesuai dengan ukuran dan throughput yang diperlukan. JanusGraph juga menggunakan backend pengindeksan yang dapat dicocokkan untuk menyediakan pengindeksan teks lengkap untuk properti verteks 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 pada StatefulSet, dan menggunakan Bigtable sebagai backend penyimpanan. Setelah selesai, Anda dapat menjelajahi hubungan yang ada dalam data grafik Anda. Diagram berikut menunjukkan bagaimana elemen-elemen ini saling melengkapi.

Deployment JanusGraph dengan Bigtable di GKE.

Diagram prceeding menunjukkan deployment JanusGraph di GKE dengan Elasticsearch danBigtable.

Data JanusGraph di Bigtable

Data grafik disimpan oleh JanusGraph sebagai daftar adjacency. Setiap baris mewakili suatu verteks, setiap verteks yang berdekatan (tepi), dan metadata properti tentang verteks dan tepian. Row key adalah pengidentifikasi unik untuk verteks. Setiap hubungan antara verteks dan verteks lain serta properti apa pun yang lebih jauh mendefinisikan hubungan tersebut disimpan sebagai kolom properti tepi atau tepi. Penentu kolom dan nilai kolom menyimpan data yang menentukan tepi, sesuai dengan praktik terbaik Bigtable. Setiap properti verteks disimpan sebagai kolom terpisah, sekali lagi menggunakan penentu kolom dan nilai kolom untuk menentukan properti.

Diagram berikut menunjukkan struktur penyimpanan ini.

Struktur penyimpanan daftar adjancency JanusGraph.

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

Ilustrasi model data logika edge verteks berikut ini memberikan sejumlah detail tentang penentu kolom dan nilai untuk kolom properti edge atau edge.

Kolom properti edge dan edge JanusGraph.

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

Diagram berikut adalah model data logika kolom properti verteks.

Nilai kolom JanusGraph untuk kolom properti.

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

Setiap properti verteks 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 Bigtable untuk baris dan penentu kolom 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.
Memuat, lalu membuat kueri data contoh.

Biaya

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

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

Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

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

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API Bigtable, Compute Engine, dan GKE .

Mengaktifkan API

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

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API Bigtable, Compute Engine, dan GKE .

Mengaktifkan API

Menyiapkan lingkungan Anda

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

Di konsol Google Cloud, aktifkan Cloud Shell.

Aktifkan Cloud Shell
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 project ID Anda.
- REGION dengan zona tempat cluster Bigtable dan cluster GKE 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
```

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 node tunggal, yang ekonomis dan memadai untuk tutorial. Anda dapat memulai project dengan cluster yang lebih kecil, lalu beralih ke cluster yang lebih besar saat Anda siap menggunakan data produksi. Dokumentasi Bigtable mencakup diskusi terperinci tentang performa dan penskalaan untuk membantu Anda memilih ukuran cluster untuk pekerjaan Anda sendiri.

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.

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 menggunakan Helm untuk men-deploy layanan JanusGraph dan Elasticsearch di cluster GKE Anda.

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

Tambahkan repositori diagram elastic agar 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 Anda.

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

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

Ambil diagram Helm dari GitHub:

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

Buka direktori Helm chart:
```
cd ${HELM_REPO}
```

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 seperti berikut, jangan lanjutkan karena integritas tag yang di-clone belum diverifikasi.

Commit hash verified

Perbarui dependensi diagram:
```
helm dep update
```
Buka direktori induk:
```
cd ..
```

Setel variabel lingkungan untuk nama entity Helm dan JanusGraph:

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

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

Deploy diagram Helm JanusGraph dengan menggunakan file values.yaml yang Anda buat:
```
helm upgrade --install \
             --wait \
              --timeout 600s \
              ${HELM_RELEASE_NAME} \
              ./${HELM_REPO} \
              -f values.yaml
```
Proses penginstalan akan menunggu hingga semua resource siap sebelum selesai. Proses ini mungkin memerlukan waktu beberapa menit.

Memverifikasi deployment JanusGraph Anda

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

Di Cloud Shell, pastikan komponen chart Helm di-deploy ke GKE:

Periksa deployment JanusGraph:

kubectl get deployments

Jika deployment berhasil, outputnya adalah sebagai berikut:

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

Periksa StatefulSet Elasticsearch:

kubectl get statefulsets

Jika semuanya berfungsi, outputnya adalah sebagai berikut:

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

Tetapkan variabel lingkungan ke nama Pod Kubernetes yang menjalankan server JanusGraph Gremlin. 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}")

Hubungkan ke Pod dan jalankan konsol Gremlin, yaitu shell read eval print loop (REPL). Nama container juga diambil 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

Di konsol Gremlin, hubungkan ke server Apache TinkerPop:

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]

Hubungkan 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>

Di konsol Gremlin, pastikan server Gremlin berjalan dengan benar dengan memeriksa variabel graph yang mewakili instance grafik:
```
graph
```
Outputnya menunjukkan bahwa server JanusGraph berjalan dengan database yang kompatibel dengan HBase, dalam hal ini Bigtable, sebagai backend penyimpanan.
```
==>standardjanusgraph[hbase:[127.0.0.1]]
```
Di Gremlin, buat dua verteks
```
v1 = graph.addVertex(label, 'hello')
v2 = graph.addVertex(label, 'world')
```
Jika output konsol mirip dengan yang berikut ini, ini menunjukkan bahwa kedua verteks telah ditambahkan:
```
==>v[4344]
==>v[4152]
```
Buat satu tepi yang menghubungkan kedua titik sudut:
```
v1.addEdge('followedBy', v2)
```
Jika output konsol serupa dengan yang berikut, hal ini menunjukkan bahwa tepi antara dua verteks telah ditambahkan:
```
==>e[17j-3co-4fmd-oe054][4344-followedBy->4152]
```
Commit transaksi:
```
graph.tx().commit()
```
Jika output konsol adalah null, ini menunjukkan bahwa operasi telah di-commit:
```
==>null
```
Diagram berikut mengilustrasikan grafik yang dibuat oleh perintah.

Verteks berlabel hello dihubungkan oleh tepi terarah berlabel followedBy ke verteks berlabel world.
Berikan kueri Gremlin untuk melihat apa label untuk verteks yang mengikuti tepi berlabel followedBy dari verteks 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 sampel

Setelah men-deploy JanusGraph dan dapat menghubungkannya menggunakan Gremlin, Anda dapat mulai memuat dan membuat kueri data Anda sendiri. Untuk melihat seperti apa proses tersebut, muat contoh set data yang dipaketkan bersama JanusGraph—Graph of the Gods, yang menggambarkan dewa mitologi panteon Romawi dan properti lokasinya.

Di Gremlin, muat grafik yang Anda buat sebelumnya:
```
GraphOfTheGodsFactory.load(graph)
```
Outputnya adalah sebagai berikut:
```
==>null
```

Berikan 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()`	Mulailah dengan pengumpulan verteks.
`has('name', 'jupiter')`	Temukan properti yang memiliki properti `name` dengan nilai `jupiter`.
`out('brother')`	Dari sana, ikuti setiap tepi yang diberi label `brother`.
`values('name')`	Untuk verteks yang menghubungkan tepi-tepi tersebut, dapatkan properti `name`.

Outputnya adalah sebagai berikut:

==>neptune
==>pluto

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

Memastikan data disimpan di Bigtable

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

Tutup konsol Gremlin:
```
:q
```
Di Cloud Shell, verifikasi bahwa data telah dipertahankan pada tabel janusgraph di Bigtable:
```
cbt -project=${PROJECT_ID} \
    -instance=${BIGTABLE_INSTANCE_ID} \
     count ${BIGTABLE_JANUSGRAPH_TABLE}
```
Output-nya mirip dengan yang berikut ini.
```
2021/03/02 02:32:19 -creds flag unset, will use gcloud credential
101
```
Nilai 101 di output mewakili jumlah baris dalam janusgraph table, dan mungkin berbeda untuk Anda.

Memverifikasi pembuatan indeks penelusuran di Elasticsearch

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-nama Pod Elasticsearch ditentukan oleh dependensi Helm Elasticsearch. Nama-nama Pod terdiri dari nama cluster seperti yang diberikan dalam file values.yaml yang Anda buat, kata master, dan angka ordinal dengan indeks nol, yang semuanya dipisahkan dengan tanda hubung. Untuk langkah ini, Anda memilih Pod pertama, yang diwakili sebagai nol (0).

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, yang dibuat oleh JanusGraph untuk menyediakan pencarian yang efisien menggunakan properti verteks dan tepi:

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

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

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 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 menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project tersebut dan hapus resource individual.

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.

Di konsol Google Cloud, buka halaman Manage resource.
Buka Manage resource
Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
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 pelajari bahasa traversal grafik Gremlin.
Pelajari lebih lanjut cara JanusGraph menyimpan data di Bigtable.
Pelajari lebih dalam kasus penggunaan grafik dengan men-deploy contoh aplikasi JanusGraph.