Dasar-Dasar Cloud Foundation Toolkit

1. Pengantar CFT 101

Terakhir diperbarui: 11-02-2022

Apa itu Cloud Foundation Toolkit?

Intinya, 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 yang diinstal di komputer Anda atau menggunakan Cloud Shell ( instal 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 dapat menulis pengujian untuk memvalidasi fitur dan memastikan integrasi yang menyeluruh.

2. Menyiapkan Lingkungan Developer

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

Menyiapkan Git

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

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

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

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

Download dan Instal Git versi terbaru

Menyetel nama pengguna dan email Anda 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

Setel 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. Repositori GCS Fork CFT

Lakukan fork ke repositori CFT

Anda sudah menyiapkan Git di mesin lokal atau Cloud Shell pada langkah sebelumnya. Sekarang Anda perlu melakukan fork pada repositori 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, {i>fork<i} digunakan untuk mengusulkan perubahan pada proyek orang lain atau menggunakan proyek 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 melakukan fork repositori 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. Anda sekarang akan meng-clone repositori ini ke lingkungan lokal untuk menambahkan fitur baru Anda.

Langkah-langkah untuk meng-clone fork:

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

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

4. Buka terminal di VSCode atau di 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.

Berdasarkan konvensi, 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 sudah siap untuk mulai mengerjakan 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. Instal 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. Instal 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 harus mendownload kunci akun layanan ke lingkungan pengujian. Akun layanan ini 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 untuk menghostingnya. 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 sudah 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 harus mendownload kunci akun layanan ke dalam 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 keyfile tersebut. 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 siap, 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 ini saat menjalankan make docker_test_prepare . Di bagian akhir , Anda akan menerima project_id pengujian yang telah dibuat tempat Anda akan men-deploy dan menguji modul Cloud Storage dengan fitur baru Anda. 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 pada output konsol. Lingkungan pengembangan dan pengujian Anda sudah disiapkan.

5. Menambahkan fitur baru ke modul CFT

Sekarang lingkungan pengembangan dan pengujian Anda sudah siap, mari mulai tambahkan "silly_label" Anda ke modul CFT Google Cloud Storage.

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

Sejak "silly_label" adalah label, Anda akan menambahkan fitur pada baris 27 di 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 ini dan 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.

Label "silly_label" perlu ditambahkan ke example/multiple-buckets/main.tf

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

Salin dan tempel baris variabel silly_label di bawah ini ke baris 27 di main.tf di terraform-google-cloud-storage/examples/multiple-buckets/ seperti yang terlihat pada 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 tersebut 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 ini:

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

Dalam kode di bawah ini, Anda mendapatkan label setiap bucket melalui perintah gcloud alpha storage, lalu memeriksa output yang dihasilkan 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-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 mengeksekusi 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 membangun program dan library yang dapat dieksekusi dari kode sumber dengan membaca file bernama Makefiles yang menentukan cara mendapatkan program target. Saat Anda membuat perubahan file, container docker harus diperbarui secara otomatis.

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

Anda akan melihat output di bawah ini di terminal Anda:

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

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

Anda akan melihat output di bawah ini di terminal Anda:

[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 menginisialisasi pengujian TestMultipleBuckets, cft test run TestMultipleBuckets --stage init. Anda juga dapat menggunakan tanda --verbose untuk mendapatkan info tambahan saat menjalankan pengujian.

Tahap init ini menginisialisasi contoh Terraform.

Anda akan melihat output di bawah ini di terminal Anda.

[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 di log. Ini adalah peringatan untuk proses debug dan dapat diabaikan. Error, jika ditemukan, akan menggagalkan pengujian.

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

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

Anda akan melihat output di bawah ini di terminal Anda.

[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 telah 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 seperti yang dideklarasikan dalam contoh.

Jika terjadi error, Anda akan melihat apa yang diharapkan dan apa yang diterima oleh perintah untuk pengujian.

Anda akan melihat output di bawah ini di terminal Anda.

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 telah dibuat dalam project beserta label yang telah Anda tambahkan ke modul GCS.

Anda dapat melihat output di bawah ini di terminal Anda.

[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 di README modul root, submodul, dan modul contoh dibuat secara otomatis berdasarkan variables dan outputs dari modul masing-masing. 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 lengkap.

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 dapat dijadikan 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

Sekarang setelah Anda 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 percabang di awal Codelab, Anda akan mengajukan Pull Request (PR) di repo master setelah melakukan 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 kode Anda sesuai dengan repo dan mungkin sekali lagi meminta Anda untuk membuat beberapa perubahan sebelum menggabungkan kode Anda ke repo master.

Jalankan langkah-langkah berikut untuk meng-commit kode ke cabang bercabang dan mengirim kode ke cabang bercabang Anda:

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 repositori 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 mendeskripsikan perubahan kode Anda. Jelaskan sedetail mungkin saat berbicara dengan ringkas.

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

Anda telah berhasil melakukan perubahan kode pertama ke cabang bercabang Anda 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 pengujian pada kode Anda 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.