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.

Contoh grafik 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 menggunakan Bigtable sebagai backend penyimpanan. Setelah selesai, Anda dapat menjelajahi hubungan yang ada dalam data grafik. Diagram berikut menunjukkan kecocokan elemen-elemen ini.

Deployment JanusGraph dengan Bigtable di GKE.

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.

Struktur penyimpanan daftar adjancency JanusGraph.

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.

Kolom tepi dan properti tepi JanusGraph.

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 edge dua arah secara signifikan meningkatkan performa traversal, tetapi disertai dengan beberapa kompromi karena redundansi ruang penyimpanan tambahan dan mutasi edge non-atomik.

Diagram berikut adalah model data logis dari kolom properti vertex.

Nilai kolom JanusGraph untuk kolom properti.

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

Biaya

Dalam dokumen ini, Anda akan 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. 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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  4. Enable the Bigtable, Compute Engine, and GKE APIs.

    Enable the APIs

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  7. Enable the Bigtable, Compute Engine, and GKE APIs.

    Enable the APIs

    8.

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. In the Google Cloud console, activate Cloud Shell.

    Activate 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 ini 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 selesai, proses penginstalan Helm 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 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, 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 rusuk 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.

    Contoh vertex dan edge JanusGraph.

    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.

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Langkah selanjutnya