Dasar-Dasar Cloud Foundation Toolkit

1. Pengantar CFT 101

Terakhir Diperbarui: 11-02-2022

Apa itu Cloud Foundation Toolkit?

Pada dasarnya, CFT menyediakan template praktik terbaik untuk memulai dengan cepat di Google Cloud Platform. Dalam tutorial ini, Anda akan belajar cara berkontribusi pada Cloud Foundation Toolkit.

Yang Anda butuhkan

• Akun GitHub.
• Docker diinstal di komputer Anda atau gunakan Cloud Shell ( penginstalan Mac, penginstalan Windows)
• Editor Kode untuk mengedit kode (Contoh: Visual Studio Code)
• Pemahaman dasar tentang Git dan GitHub
• Pengalaman dengan Terraform dan Infrastructure as Code
• Izin untuk memberikan peran Project Creator ke Akun Layanan
• Organisasi Google Cloud, folder pengujian, dan akun penagihan

Yang akan Anda bangun

Dalam codelab ini, Anda akan mempelajari cara berkontribusi pada Cloud Foundation Toolkit (CFT).

Anda akan:

• Menyiapkan lingkungan pengembangan untuk berkontribusi pada CFT
• Menambahkan fitur ke modul CFT
• Menambahkan pengujian untuk fitur yang ditambahkan
• Menjalankan pengujian integrasi di CFT
• Menjalankan pengujian lint
• Commit kode ke GitHub dan kirimkan Permintaan Pull (PR)

Anda akan menjalankan semua langkah di atas dengan menambahkan fitur baru ke modul CFT Google Cloud Storage. Anda akan menambahkan label bernama "silly_label" yang akan ditambahkan secara otomatis ke semua bucket yang dibuat melalui modul CFT GCS. Anda juga akan menulis pengujian untuk memvalidasi fitur dan memastikan integrasi menyeluruh.

2. Menyiapkan Lingkungan Developer

Jika mau, Anda dapat menggunakan Cloud Shell untuk tujuan pengembangan. Jika tidak ingin menggunakan Cloud Shell untuk berkontribusi pada CFT, Anda dapat menyiapkan lingkungan pengembangan di komputer.

Menyiapkan Git

GitHub didasarkan pada sistem kontrol versi (VCS) open source yang disebut Git. Git bertanggung jawab atas semua hal terkait GitHub yang terjadi secara lokal di komputer atau Cloud Shell Anda.

1. Saat menggunakan Cloud Shell, Anda tidak perlu menginstal git karena sudah diinstal sebelumnya.

$ git --version
# This will display the git version on the Cloud Shell.

Jika Anda menyiapkan lingkungan pengembangan di mesin, Anda perlu menginstal Git.

Mendownload dan Menginstal Git versi terbaru

Menetapkan nama pengguna dan email di Git

Git menggunakan nama pengguna untuk mengaitkan commit dengan identitas. Nama pengguna Git tidak sama dengan nama pengguna GitHub Anda.

Anda dapat mengubah nama yang terkait dengan commit Git menggunakan perintah git config. Mengubah nama yang terkait dengan commit Git Anda menggunakan git config hanya akan memengaruhi commit mendatang dan tidak akan mengubah nama yang digunakan untuk commit sebelumnya.

Menyetel nama pengguna Git untuk setiap repositori di komputer Anda

Untuk Mac/Linux: Buka Terminal

Untuk Windows: Buka Git Bash

Tetapkan nama pengguna Git:

$ git config --global user.name "Your Name"

$ git config --global user.email "[e-mail]"

Pastikan Anda telah menetapkan nama pengguna Git dengan benar:

$ git config --list

> Your Name

> Your Email

Anda telah berhasil menyiapkan Git dan seharusnya dapat melakukan fork, membuat, dan meng-clone cabang. Kita akan menggunakan Git secara ekstensif dalam Codelab ini.

3. Menyalin Repositori GCS CFT

Lakukan fork ke repositori CFT

Anda telah menyiapkan Git di komputer lokal atau Cloud Shell pada langkah sebelumnya. Sekarang Anda perlu melakukan fork pada repo CFT Google Cloud Storage untuk mulai berkontribusi.

Fork adalah salinan repositori. Dengan forking repositori, Anda dapat bebas bereksperimen dengan perubahan tanpa memengaruhi project aslinya.

Umumnya, fork digunakan untuk mengusulkan perubahan pada project orang lain atau menggunakan project orang lain sebagai titik awal untuk ide Anda sendiri.

Misalnya, Anda dapat menggunakan fork untuk mengusulkan perubahan terkait dengan perbaikan bug. Untuk memperbaiki bug, Anda dapat:

• Lakukan fork pada repositori.
• Lakukan perbaikan.
• Kirim permintaan pull ke pemilik project.

Langkah-langkah untuk membuat fork repo CFT:

1. Buka browser web Anda dan buka repositori terraform-google-modules/terraform-google-cloud-storage. Kita akan menggunakan repo ini untuk seluruh Codelab.
2. Di pojok kanan atas halaman, klik Fork.

3. Anda akan diberikan opsi di mana Anda ingin memiliki fork, pilih profil Anda, dan repo akan diambil.

Meng-clone fork secara lokal

Fork yang Anda buat adalah salinan repositori modul GCS. Sekarang Anda akan meng-clone repositori ini ke lingkungan lokal untuk menambahkan fitur baru Anda.

Langkah-langkah untuk meng-clone fork Anda:

1. Buka browser web, lalu buka fork Anda di terraform-google-modules/terraform-google-cloud-storage.
2. Di pojok kanan atas, Anda akan menemukan tombol "Code", klik tombol tersebut.

3. Setelah mengklik tombol "Code", klik ikon "Copy" untuk menyalin URL fork. Anda akan menggunakan URL ini untuk meng-clone fork ke lingkungan lokal.

4. Buka terminal di VSCode atau komputer Anda dan clone fork.

$ git clone <url>
# This command will clone your fork locally.
# Paste the copied URL from the previous step.

5. Setelah meng-clone fork secara lokal, Anda harus membuka repo, membuat cabang baru dari fork, dan membuat perubahan kode pada cabang sementara.

Secara umum, Anda dapat memberi nama cabang sebagai berikut:

• Untuk permintaan fitur: feature/feature-name
• Untuk update internal, internal/change-name
• Untuk perbaikan bug: bugfix/issue-name

Karena Anda menambahkan fitur baru, Anda dapat memanggil cabang sementara feature/silly_label

$ cd terraform-google-cloud-storage
# This command takes you into the cloned directory on your local machine.

$ git branch
# This command tells your current branch
# When you run this for the first time after you have cloned, your 
# output should say "master", that is your fork.

$ git checkout -b feature/silly_label
# This command creates a new branch on your fork and switches your 
# branch to the newly created branch.

$ git branch
# This command will confirm your current branch to be "feature/silly_label"

Sekarang Anda siap untuk mulai bekerja di Cloud Foundation Toolkit.

4. Membuat lingkungan pengujian

Proses pengembangan CFT standar didasarkan pada penggunaan project pengujian terisolasi untuk pengujian. Langkah ini akan memandu Anda membuat project pengujian (berdasarkan konfigurasi standar) melalui akun layanan.

0. Menginstal Docker Engine

Jika menggunakan komputer untuk tujuan pengembangan, Anda harus menginstal Docker Engine.

Catatan: Jika menggunakan Cloud Shell, Anda tidak perlu menginstal Docker karena Cloud Shell sudah memilikinya.

1. Menginstal Google Cloud SDK

Anda tidak perlu menginstal Google Cloud SDK jika menggunakan Cloud Shell GCP.

Buka Google Cloud SDK dan download penginstal interaktif untuk platform Anda.

2. Setel konfigurasi

Untuk membuat lingkungan pengujian, Anda memerlukan Organisasi Google Cloud, folder pengujian, dan akun penagihan. Nilai ini harus ditetapkan melalui variabel lingkungan:

export TF_VAR_org_id="your_org_id"
export TF_VAR_folder_id="your_folder_id"
export TF_VAR_billing_account="your_billing_account_id"

3. Menyiapkan Akun Layanan

Sebelum membuat lingkungan pengujian, Anda perlu mendownload kunci akun layanan ke lingkungan pengujian. Akun layanan ini akan memerlukan peran Project Creator, Billing Account User, dan Organization Viewer. Langkah-langkah ini akan membantu Anda membuat akun layanan baru, tetapi Anda juga dapat menggunakan kembali akun yang sudah ada.

3.1 Membuat atau Memilih Project GCP Seed

Sebelum membuat akun layanan, Anda harus memilih project tempat akun tersebut akan dihosting. Anda juga dapat membuat project baru.

gcloud config set core/project YOUR_PROJECT_ID

3.2 Mengaktifkan Google Cloud API

Aktifkan Google Cloud API berikut di project seed Anda:

gcloud services enable cloudresourcemanager.googleapis.com
gcloud services enable iam.googleapis.com
gcloud services enable cloudbilling.googleapis.com

3.3 Membuat Akun Layanan

Buat akun layanan baru untuk mengelola lingkungan pengujian:

# Creating a service account for CFT.
gcloud iam service-accounts create cft-onboarding \
  --description="CFT Onboarding Terraform Service Account" \
  --display-name="CFT Onboarding"

# Assign SERVICE_ACCOUNT environment variable for later steps
export SERVICE_ACCOUNT=cft-onboarding@$(gcloud config get-value core/project).iam.gserviceaccount.com

Pastikan akun layanan Anda telah dibuat:

gcloud iam service-accounts list --filter="EMAIL=${SERVICE_ACCOUNT}"

3.4 Memberikan peran Project Creator, Billing Account User, dan Organization Viewer ke Akun Layanan:

gcloud resource-manager folders add-iam-policy-binding ${TF_VAR_folder_id} \
  --member="serviceAccount:${SERVICE_ACCOUNT}" \
  --role="roles/resourcemanager.projectCreator"
gcloud organizations add-iam-policy-binding ${TF_VAR_org_id} \
  --member="serviceAccount:${SERVICE_ACCOUNT}" \
  --role="roles/billing.user"
gcloud beta billing accounts add-iam-policy-binding ${TF_VAR_billing_account} \
  --member="serviceAccount:${SERVICE_ACCOUNT}" \
  --role="roles/billing.user"
gcloud organizations add-iam-policy-binding ${TF_VAR_org_id} \
  --member="serviceAccount:${SERVICE_ACCOUNT}" \
  --role="roles/resourcemanager.organizationViewer"

Sekarang Anda memiliki Akun Layanan yang dapat digunakan untuk mengelola lingkungan pengujian.

4. Siapkan Kredensial Terraform

Untuk membuat lingkungan pengujian, Anda perlu mendownload kunci akun layanan ke shell.

4.1 Kunci Akun Layanan

Membuat dan mendownload kunci akun layanan untuk Terraform

gcloud iam service-accounts keys create cft.json --iam-account=${SERVICE_ACCOUNT}

4.2 Menyiapkan Kredensial Terraform

Sediakan kunci ke Terraform menggunakan variabel lingkungan SERVICE_ACCOUNT_JSON, dengan menyetel nilai ke contents kunci akun layanan Anda.

export SERVICE_ACCOUNT_JSON=$(< cft.json)

Setelah menyimpan informasi kredensial dalam variabel lingkungan, hapus file kunci. Anda dapat membuat ulang kunci nanti jika diperlukan menggunakan perintah yang sama di atas.

rm -rf cft.json

5. Membuat project pengujian untuk deployment Terraform

Setelah semuanya disiapkan, Anda dapat membuat project pengujian dengan satu perintah. Jalankan perintah ini dari root direktori terraform-google-cloud-storage:

make docker_test_prepare

Anda akan melihat output di bawah saat menjalankan make docker_test_prepare. Pada akhirnya , Anda akan menerima project_id pengujian yang telah dibuat tempat Anda akan men-deploy dan menguji modul Cloud Storage dengan fitur baru. Jika Anda mengalami masalah saat menautkan akun penagihan, lihat langkah-langkah pemecahan masalah.

macbookpro3:terraform-google-cloud-storage user$ make docker_test_prepare
docker run --rm -it \
                -e SERVICE_ACCOUNT_JSON \
                -e TF_VAR_org_id \
                -e TF_VAR_folder_id \
                -e TF_VAR_billing_account \
                -v /Users/cft/terraform-google-cloud-storage:/workspace \
                gcr.io/cloud-foundation-cicd/cft/developer-tools:0.8.0 \
                /usr/local/bin/execute_with_credentials.sh prepare_environment
Activated service account credentials for: [cft-onboarding@<project_id>.iam.gserviceaccount.com]
Activated service account credentials for: [cft-onboarding@<project_id>.iam.gserviceaccount.com]
Initializing modules...

Initializing the backend...

Initializing provider plugins...

The following providers do not have any version constraints in configuration,
so the latest version was installed.

To prevent automatic upgrades to new major versions that may contain breaking
changes, it is recommended to add version = "..." constraints to the
corresponding provider blocks in configuration, with the constraint strings
suggested below.

* provider.google-beta: version = "~> 3.9"
* provider.null: version = "~> 2.1"
* provider.random: version = "~> 2.2"

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.
module.project.module.project-factory.null_resource.preconditions: Refreshing state... [id=8723188031607443970]
module.project.module.project-factory.null_resource.shared_vpc_subnet_invalid_name[0]: Refreshing state... [id=5109975723938185892]
module.project.module.gsuite_group.data.google_organization.org[0]: Refreshing state...
module.project.module.project-factory.random_id.random_project_id_suffix: Refreshing state... [id=rnk]
module.project.module.project-factory.google_project.main: Refreshing state... [id=<project-id>]
module.project.module.project-factory.google_project_service.project_services[0]: Refreshing state... [id=<project-id>/storage-api.googleapis.com]
module.project.module.project-factory.google_project_service.project_services[1]: Refreshing state... [id=<project-id>/cloudresourcemanager.googleapis.com]
module.project.module.project-factory.google_project_service.project_services[2]: Refreshing state... [id=<project-id>/compute.googleapis.com]
module.project.module.project-factory.data.null_data_source.default_service_account: Refreshing state...
module.project.module.project-factory.google_service_account.default_service_account: Refreshing state... [id=projects/ci-cloud-storage-ae79/serviceAccounts/project-service-account@<project-id>.iam.gserv
iceaccount.com]
module.project.module.project-factory.google_project_service.project_services[3]: Refreshing state... [id=<project-id>/serviceusage.googleapis.com]
module.project.module.project-factory.null_resource.delete_default_compute_service_account[0]: Refreshing state... [id=3576396874950891283]
google_service_account.int_test: Refreshing state... [id=projects/<project-id>/serviceAccounts/cft-onboarding@<project-id>.iam.gserviceaccount.com]
google_service_account_key.int_test: Refreshing state... [id=projects/<project-id>/serviceAccounts/cft-onboarding@<project-id>.iam.gserviceaccount.com/keys/351009a1e011e88049ab2097994d1c627a61
6961]
google_project_iam_member.int_test[1]: Refreshing state... [id=<project-id>/roles/iam.serviceAccountUser/serviceaccount:cft-onboarding@<project-id>.iam.gserviceaccount.com]
google_project_iam_member.int_test[0]: Refreshing state... [id=<project-id>/roles/storage.admin/serviceaccount:cft-onboarding@<project-id>.iam.gserviceaccount.com]

Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

project_id = <test-project-id>
sa_key = <sensitive>
Found test/setup/make_source.sh. Using it for additional explicit environment configuration.

Sekarang Anda telah membuat project pengujian yang direferensikan oleh project_id seperti yang dapat Anda lihat di output konsol. Lingkungan pengembangan dan pengujian Anda sudah disiapkan.

5. Menambahkan fitur baru ke modul CFT

Setelah lingkungan pengembangan dan pengujian disiapkan, mari kita mulai menambahkan fitur "silly_label" ke modul CFT google-cloud-storage.

Pastikan Anda berada di terraform-google-cloud-storage dan buka file main.tf seperti yang Anda lihat di bawah dalam struktur folder.

Karena "silly_label" adalah label, Anda akan menambahkan fitur di baris 27 dalam variabel "labels" di main.tf, seperti yang Anda lihat di bawah ini:

terraform-google-cloud-storage/main.tf

resource "google_storage_bucket" "buckets" {
 <...>
 storage_class = var.storage_class
 // CODELAB:Add silly label in labels variable
 labels        = merge(var.labels, { name = replace("${local.prefix}${lower(each.value)}", ".", "-") }, { "silly" = var.silly_label })
 force_destroy = lookup(
 <...>
}

Sekarang, Anda akan menambahkan variabel silly_label dalam variables.tf yang terlihat pada struktur folder di atas.

Salin dan tempel kode di bawah, lalu tambahkan ke baris 31 di variables.tf dan pastikan Anda memiliki karakter baris baru di atas dan di bawah blok variabel yang ditambahkan.

terraform-google-cloud-storage/variables.tf

variable "names" {
 description = "Bucket name suffixes."
 type        = list(string)
}

// CODELAB: Add "silly_label" variable to variables.tf between "names" and "location"
variable "silly_label" {
 description = "Sample label for bucket."
 type        = string
}

variable "location" {
 description = "Bucket location."
 default     = "EU"
}

6. Menambahkan fitur baru ke contoh bucket penyimpanan

Anda telah menambahkan fitur ke main.tf modul dan sekarang Anda akan menguji fitur yang ditambahkan melalui contoh.

"silly_label" harus ditambahkan ke examples/multiple-buckets/main.tf

Contoh ini akan digunakan di langkah berikutnya untuk melakukan pengujian integrasi.

Salin dan tempel baris variabel silly_label di bawah ke baris 27 di main.tf di terraform-google-cloud-storage/examples/multiple-buckets/ seperti yang terlihat dalam struktur folder:

terraform-google-cloud-storage/examples/multiple-buckets/main.tf

module "cloud_storage" {
 <...>
 // CODELAB: Add "silly_label" as an example to main.tf.
 silly_label        = "awesome"

 <..>
}

7. Mengupdate pengujian blueprint untuk memeriksa fitur

Anda telah menambahkan fitur ke main.tf modul, lalu menambahkan fitur ke contoh multiple_buckets. Sekarang, Anda perlu menguji fitur melalui pengujian integrasi blueprint yang ditulis dalam Golang.

Anda akan menambahkan pengujian baru dalam file multiple_buckets_test.go yang ditemukan dalam struktur folder di bawah:

Anda telah menambahkan "silly_label" di semua bucket yang dibuat melalui modul multiple_buckets dan sekarang Anda perlu menulis pengujian untuk menguji fitur baru.

Dalam kode di bawah, Anda mendapatkan label setiap bucket melalui perintah gcloud alpha storage, lalu memeriksa output yang ditampilkan dari perintah tersebut.

test/integration/multiple_buckets/multiple_buckets_test.go

func TestMultipleBuckets(t *testing.T) {
 <..>
op := gcloud.Run(t, fmt.Sprintf("alpha storage ls --buckets gs://%s", bucketName), gcloudArgs).Array()[0]

// verify silly label on each bucket
assert.Equal("awesome", op.Get("metadata.labels.silly").String(), "should have silly label set to awesome")

// verify lifecycle rules
...
}

8. Menjalankan pengujian integrasi di CFT

Pengujian Integrasi

Pengujian integrasi digunakan untuk memverifikasi perilaku modul root, submodul, dan contoh. Penambahan, perubahan, dan perbaikan harus disertai dengan pengujian.

Pengujian integrasi ditulis menggunakan framework pengujian blueprint dan dijalankan menggunakan CFT CLI. Alat ini dikemas dalam image Docker untuk memudahkan.

Strategi umum untuk pengujian ini adalah memverifikasi perilaku modul contoh, sehingga memastikan bahwa modul root, submodul, dan modul contoh semuanya benar secara fungsional.

Dalam eksekusi interaktif, Anda menjalankan setiap langkah melalui beberapa perintah.

1. Jalankan make docker_run untuk memulai container Docker pengujian dalam mode interaktif.

Make adalah alat otomatisasi build yang otomatis mem-build program dan library yang dapat dieksekusi dari kode sumber dengan membaca file yang disebut Makefile yang menentukan cara memperoleh program target. Saat Anda membuat perubahan file, penampung docker harus diperbarui secara otomatis.

Saat menjalankan make docker_run, Anda akan membuat ruang kerja di penampung docker dan mengaktifkan kredensial untuk akun layanan. Ruang kerja akan digunakan di langkah berikutnya untuk menjalankan pengujian.

Anda akan melihat output di bawah ini di terminal:

Activated service account credentials for: [cft@<PROJECT_ID>.iam.gserviceaccount.com]

2. Jalankan cft test list untuk mencantumkan semua pengujian blueprint di ruang kerja Anda.

Anda akan melihat output di bawah ini di terminal:

[root@CONTAINER_ID workspace]# cft test list
 NAME                           | CONFIG                    | LOCATION                                                   
--------------------------------+---------------------------+------------------------------------------------------------
 TestAll/examples/simple_bucket | examples/simple_bucket    | test/integration/discover_test.go                          
 TestMultipleBuckets            | examples/multiple_buckets | test/integration/multiple_buckets/multiple_buckets_test.go 

3. Jalankan cft test run <EXAMPLE_NAME> --stage init untuk melakukan inisialisasi contoh. Dalam hal ini, untuk melakukan inisialisasi operasi pengujian TestMultipleBuckets, cft test run TestMultipleBuckets --stage init. Anda juga dapat menggunakan flag --verbose untuk mendapatkan info tambahan saat menjalankan pengujian.

Tahap init ini menginisialisasi contoh Terraform.

Anda akan melihat output di bawah ini di terminal.

[root@<CONTAINER_ID> workspace]# cft test run TestMultipleBuckets --stage init --verbose
INFO[02-09|08:24:31] using test-dir: test/integration 
...
TestMultipleBuckets 2022-02-09T08:24:35Z command.go:179: Terraform has been successfully initialized!
...
TestMultipleBuckets 2022-02-09T08:24:35Z command.go:100: Running command terraform with args [validate]
TestMultipleBuckets 2022-02-09T08:24:36Z command.go:179: Success! The configuration is valid.
...
--- PASS: TestMultipleBuckets (4.05s)

Catatan: Anda mungkin melihat peringatan seperti Skipping fixtures discovery dalam log. Ini adalah peringatan untuk proses debug dan dapat diabaikan. Error, jika terjadi, akan menyebabkan pengujian gagal.

4. Jalankan cft test run <EXAMPLE_NAME> --stage apply untuk menerapkan modul contoh.

Langkah ini menerapkan contoh yang diinisialisasi pada tahap sebelumnya ke project GCP yang dibuat sebelumnya di Codelab.

Anda akan melihat output di bawah ini di terminal.

[root@<CONTAINER_ID> workspace]# cft test run TestMultipleBuckets --stage apply --verbose
INFO[02-09|08:28:11] using test-dir: test/integration
...
TestMultipleBuckets 2022-02-09T08:28:19Z command.go:179: Apply complete! Resources: 6 added, 0 changed, 0 destroyed.
TestMultipleBuckets 2022-02-09T08:28:19Z command.go:179: 
TestMultipleBuckets 2022-02-09T08:28:19Z command.go:179: Outputs:
TestMultipleBuckets 2022-02-09T08:28:19Z command.go:179: 
TestMultipleBuckets 2022-02-09T08:28:19Z command.go:179: names = {
TestMultipleBuckets 2022-02-09T08:28:19Z command.go:179:   "one" = "multiple-buckets-erp1-eu-one"
...
--- PASS: TestMultipleBuckets (6.51s)
PASS
ok      github.com/terraform-google-modules/terraform-google-cloud-storage/test/integration/multiple_buckets    6.548s

5. Jalankan cft test run <EXAMPLE_NAME> --stage verify untuk memverifikasi bahwa contoh membuat infrastruktur yang diharapkan.

Langkah ini akan menjalankan fungsi verifikasi di TestMultipleBuckets. Biasanya verifikasi dilakukan dengan mengeksekusi perintah gcloud untuk mengambil output JSON untuk status resource saat ini dan menyatakan bahwa status saat ini sebagaimana dideklarasikan dalam contoh.

Jika mendapatkan error, Anda akan melihat hal yang diharapkan dan yang diterima oleh perintah untuk pengujian.

Anda akan melihat output di bawah ini di terminal.

cft test run TestMultipleBuckets --stage verify --verbose
INFO[02-09|08:30:19] using test-dir: test/integration
...
TestMultipleBuckets 2022-02-09T08:30:27Z command.go:100: Running command terraform with args [output -no-color -json names_list]
TestMultipleBuckets 2022-02-09T08:30:27Z command.go:179: ["multiple-buckets-erp1-eu-one","multiple-buckets-erp1-eu-two"]
TestMultipleBuckets 2022-02-09T08:30:27Z command.go:100: Running command gcloud with args [alpha storage ls --buckets gs://multiple-buckets-erp1-eu-one --project ci-cloud-storage-8ce9 --json]
TestMultipleBuckets 2022-02-09T08:30:28Z command.go:179: [
TestMultipleBuckets 2022-02-09T08:30:28Z command.go:179: {
TestMultipleBuckets 2022-02-09T08:30:28Z command.go:179:   "url": "gs://multiple-buckets-erp1-eu-one/",
...
TestMultipleBuckets 2022-02-09T08:30:33Z command.go:179: ]
2022/02/09 08:30:33 RUN_STAGE env var set to verify
2022/02/09 08:30:33 Skipping stage teardown
--- PASS: TestMultipleBuckets (12.32s)
PASS
ok      github.com/terraform-google-modules/terraform-google-cloud-storage/test/integration/multiple_buckets    12.359s

6. Jalankan cft test run <EXAMPLE_NAME> --stage teardown untuk membongkar contoh.

Langkah ini akan menghancurkan infrastruktur yang Anda buat pada langkah-langkah di atas. Langkah ini juga akan menghancurkan bucket GCS yang dibuat dalam project beserta label yang Anda tambahkan ke modul GCS.

Anda dapat melihat output di bawah di terminal.

[root@<CONTAINER_ID> workspace]# cft test run TestMultipleBuckets --stage teardown --verbose
INFO[02-09|08:36:02] using test-dir: test/integration
...
TestMultipleBuckets 2022-02-09T08:36:06Z command.go:100: Running command terraform with args [destroy -auto-approve -input=false -lock=false]
TestMultipleBuckets 2022-02-09T08:36:07Z command.go:179: module.cloud_storage.random_id.bucket_suffix: Refreshing state... [id=mNA]
TestMultipleBuckets 2022-02-09T08:36:07Z command.go:179: random_string.prefix: Refreshing state... [id=erp1]
TestMultipleBuckets 2022-02-09T08:36:08Z command.go:179: module.cloud_storage.google_storage_bucket.buckets["two"]: Refreshing state... [id=multiple-buckets-erp1-eu-two]
...
TestMultipleBuckets 2022-02-09T08:36:10Z command.go:179: Destroy complete! Resources: 6 destroyed.
TestMultipleBuckets 2022-02-09T08:36:10Z command.go:179: 
--- PASS: TestMultipleBuckets (6.62s)
PASS
ok      github.com/terraform-google-modules/terraform-google-cloud-storage/test/integration/multiple_buckets    6.654s

7. Jalankan exit untuk keluar dari container pengujian.

9. Membuat Dokumentasi untuk Input dan Output

Tabel Input dan Output dalam README modul root, submodul, dan modul contoh dibuat secara otomatis berdasarkan variables dan outputs dari masing-masing modul. Tabel ini harus dimuat ulang jika antarmuka modul diubah.

Jalankan:

make generate_docs
# This will generate new Inputs and Outputs tables

Ingat: Selalu jalankan generate_docs untuk memastikan semua dokumentasi sudah selesai.

10. Menjalankan pengujian lint di CFT

Linter adalah alat yang menganalisis kode sumber untuk menandai error pemrograman, bug, error gaya, dan konstruksi yang mencurigakan.

Banyak file dalam repositori yang dapat di-lint atau diformat untuk mempertahankan standar kualitas. Untuk memastikan kualitas di CFT, Anda akan menggunakan pengujian lint.

Jalankan:

make docker_test_lint
# This will run all lint tests on your repo

Ingat: Selalu jalankan pengujian lint karena Cloud Build akan gagal jika analisis lint tidak selesai. Jalankan ini sebelum menyimpan kode ke repo lokal Anda.

11. Mengirimkan PR di GitHub

Setelah mengubah kode secara lokal dan mengujinya melalui pengujian integrasi, Anda ingin memublikasikan kode ini ke repo master.

Agar kode tersedia di repo master, Anda harus meng-commit perubahan kode ke cabang dan mengirimnya ke repositori master. Agar kode Anda ditambahkan ke repo utama yang Anda buat fork di awal Codelab, Anda akan mengajukan Pull Request (PR) di repo master setelah melakukan commit kode ke repo Anda.

Saat Anda mengajukan PR, admin repo akan diberi tahu untuk meninjau perubahan kode yang diusulkan. Selain itu, Anda juga dapat menambahkan pengguna lain sebagai peninjau untuk mendapatkan masukan tentang perubahan kode Anda. PR akan memicu Cloud Build yang akan menjalankan pengujian di repo.

Berdasarkan perubahan kode Anda, peninjau kode akan memberikan komentar pada kode Anda dan meminta modifikasi jika ada sesuatu yang perlu diubah berdasarkan praktik terbaik dan dokumentasi. Admin akan meninjau perubahan kode Anda, memastikan bahwa kode Anda mematuhi repo, dan mungkin meminta Anda untuk melakukan beberapa perubahan lagi sebelum menggabungkan kode ke repo master.

Jalankan langkah-langkah berikut untuk melakukan commit kode ke cabang yang di-fork dan mendorong kode ke cabang yang di-fork:

1. Langkah pertama adalah menambahkan file yang diubah ke repositori lokal.

$ git add main.tf
$ git add README.md
$ git add variables.tf
$ git add examples/multiple-buckets/main.tf
$ git add test/integration/multiple_buckets/multiple_buckets_test.go
# The ‘git add' command adds the file in the local repository and 
# stages the file for commit. To unstage a file, use git reset HEAD YOUR-FILE

2. File Anda kini sudah disiapkan, selanjutnya Anda akan melakukan commit untuk perubahan tersebut.

$ git commit -m "First CFT commit"
# This will commit the staged changes and prepares them to be pushed 
# to a remote repository. To remove this commit and modify the file, 
# use 'git reset --soft HEAD~1' and commit and add the file again.

3. Kirim perubahan yang di-commit di repositori lokal Anda ke GitHub untuk membuat Pull Request (PR).

$ git push -u origin feature/silly_label
# Pushes the changes in your local repository up to the remote
# repository you specified as the origin

Perubahan kode Anda sekarang siap untuk Permintaan Pull!

Jalankan langkah-langkah berikut untuk membuat PR ke repo terraform-google-modules/terraform-google-cloud-storage :

1. Di browser web Anda, buka halaman utama repo.
2. Anda akan melihat saran melalui banner untuk membuka PR dari fork. Klik "Bandingkan dan pull request".

3. Masukkan judul dan deskripsi untuk permintaan pull Anda guna menjelaskan perubahan kode Anda. Jelaskan sespesifik mungkin, tetapi tetap ringkas.

4. Untuk membuat permintaan pull yang siap ditinjau, klik "Create Pull Request".
5. Anda akan melihat Pemicu Cloud Build yang berjalan dan dipicu karena PR.
6. Lihat dokumen GitHub resmi tentang membuka permintaan pull dari fork jika Anda mengalami masalah.

Anda telah berhasil mendorong perubahan kode pertama ke cabang yang di-fork dan mengajukan PR CFT pertama terhadap cabang master.

12. Selamat

Selamat, Anda telah berhasil menambahkan fitur ke modul CFT dan mengirimkan PR untuk ditinjau.

Anda telah menambahkan fitur ke modul CFT, mengujinya secara lokal melalui contoh, dan melakukan pengujian sebelum melakukan commit kode ke GitHub. Terakhir, Anda mengajukan PR untuk ditinjau dan penggabungan terakhir menjadi CFT.

Sekarang Anda telah mengetahui langkah-langkah penting untuk mulai menggunakan Cloud Foundation Toolkit.