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

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

  1. 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.
  2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

    Buka pemilih project

  3. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

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

    Mengaktifkan API

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

    Buka pemilih project

  6. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

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

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

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

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

  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 Helm chart:

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

    Commit hash verified
    
  5. Perbarui dependensi diagram:

    helm dep update
    
  6. Buka direktori induk:

    cd ..
    
  7. 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
    
  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 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.

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

    1. 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
      
    2. Periksa StatefulSet Elasticsearch:

      kubectl get statefulsets
      

      Jika semuanya berfungsi, outputnya 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 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}")
    
  3. 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
    
  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. 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>
      
  5. 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]]
    
  6. 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]
    
  7. 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]
    
  8. 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.

    Contoh verteks dan tepi JanusGraph.

    Verteks berlabel hello dihubungkan oleh tepi terarah berlabel followedBy ke verteks berlabel world.

  9. 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.

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

    GraphOfTheGodsFactory.load(graph)
    

    Outputnya adalah sebagai berikut:

    ==>null
    
  2. 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.

  1. Tutup konsol Gremlin:

    :q
    
  2. 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

  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-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).

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

    {
      "janusgraph_vertices" : {
        "aliases" : {
          "janusgraph" : { }
        }
      },
      "janusgraph_edges" : {
        "aliases" : {
          "janusgraph" : { }
        }
      }
    }
    
  3. 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.

  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