इस पेज का अनुवाद Cloud Translation API से किया गया है.

क्लाउड फ़ाउंडेशन टूलकिट 101

1. CFT 101 के बारे में जानकारी

पिछले अपडेट की तारीख: 11-02-2022

Cloud Foundation Toolkit क्या है?

असल में, CFT, Google Cloud Platform का इस्तेमाल तुरंत शुरू करने के लिए, सबसे सही तरीके के टेंप्लेट उपलब्ध कराता है. इस ट्यूटोरियल में, आपको Cloud Foundation टूलकिट में योगदान देने का तरीका बताया गया है.

आपको इन चीज़ों की ज़रूरत होगी

GitHub खाता.
Docker अपनी मशीन पर इंस्टॉल करें या Cloud Shell का इस्तेमाल करें ( Mac इंस्टॉल, Windows इंस्टॉल)
कोड में बदलाव करने के लिए कोड एडिटर (उदाहरण: विज़ुअल स्टूडियो कोड)
Git और GitHub के बारे में बुनियादी जानकारी
Terraform और कोड के तौर पर इंफ़्रास्ट्रक्चर का इस्तेमाल करने का कुछ अनुभव
सेवा खाते को प्रोजेक्ट क्रिएटर की भूमिका देने की अनुमति
Google Cloud संगठन, एक टेस्ट फ़ोल्डर, और एक बिलिंग खाता

आपको क्या बनाना है

इस कोडलैब की मदद से, आपको Cloud Foundation Toolkit (CFT) में योगदान देने का तरीका पता चलेगा.

ऐसा करने पर:

सीएफ़टी में योगदान देने के लिए, डेवलपर एनवायरमेंट को सेटअप करें
सीएफ़टी मॉड्यूल में कोई सुविधा जोड़ना
जोड़ी गई सुविधा के लिए टेस्ट जोड़ना
सीएफ़टी में इंटिग्रेशन टेस्ट चलाना
लिंट टेस्ट चलाना
GitHub पर कोड को कमिट करना और पुल रिक्वेस्ट (पीआर) सबमिट करना

Google Cloud Storage CFT मॉड्यूल में नई सुविधा जोड़कर, ऊपर दिए गए सभी चरणों को पूरा किया जा सकता है. आपको "silly_label" नाम का एक लेबल जोड़ना होगा. यह लेबल, GCS CFT मॉड्यूल की मदद से बनाई गई सभी बकेट में अपने-आप जुड़ जाएगा. आपको अपनी सुविधा की पुष्टि करने और एंड-टू-एंड इंटिग्रेशन की पुष्टि करने के लिए, टेस्ट भी लिखने होंगे.

2. डेवलपमेंट एनवायरमेंट सेटअप करना

अगर आप चाहें, तो अपने डेवलपमेंट के मकसद से Cloud Shell का इस्तेमाल किया जा सकता है. अगर आपको सीएफ़टी में योगदान देने के लिए, Cloud Shell का इस्तेमाल नहीं करना है, तो अपनी मशीन पर डेवलपर एनवायरमेंट को सेट अप किया जा सकता है.

Git सेट अप करना

GitHub एक ओपन सोर्स वर्शन कंट्रोल सिस्टम (VCS) पर आधारित है, जिसे Git कहते हैं. GitHub से जुड़ी हर उस चीज़ के लिए Git ज़िम्मेदार होता है जो आपकी मशीन या Cloud Shell पर स्थानीय तौर पर होती है.

Cloud Shell का इस्तेमाल करते समय, आपको git इंस्टॉल करने की ज़रूरत नहीं है, क्योंकि यह पहले से इंस्टॉल होता है.

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

अगर आपको अपनी मशीन पर डेवलपर एनवायरमेंट सेट अप करना है, तो आपको Git इंस्टॉल करना होगा.

Git में अपना उपयोगकर्ता नाम और ईमेल पता सेट करना

Git, किसी आइडेंटिटी से कमिट को जोड़ने के लिए, उपयोगकर्ता नाम का इस्तेमाल करता है. Git उपयोगकर्ता नाम, आपके GitHub उपयोगकर्ता नाम से अलग होता है.

git config कमांड का इस्तेमाल करके, अपने Git कमिट से जुड़ा नाम बदला जा सकता है. git config का इस्तेमाल करके, Git कमिट से जुड़ा नाम बदलने पर, सिर्फ़ आने वाले समय में की जाने वाली कमिट पर असर पड़ेगा. इससे, पहले की गई कमिट के लिए इस्तेमाल किए गए नाम में कोई बदलाव नहीं होगा.

आपने Git को सही तरीके से सेट अप कर लिया है. अब आपके पास शाखाओं को फ़ॉर्क करने, बनाने, और क्लोन करने का विकल्प होगा. हम इस कोडलैब (कोड बनाना सीखना) में Git का भरपूर इस्तेमाल करेंगे.

3. फ़ोर्क CFT की GCS रिपॉज़िटरी

सीएफ़टी रिपॉज़िटरी को फ़ॉर्क करना

आपने पिछले चरण में, अपनी लोकल मशीन या Cloud Shell पर Git सेट अप किया हो. अब योगदान देने के लिए, आपको Google Cloud Storage CFT repo को फ़ॉर्क करना होगा.

फ़ॉर्क, किसी रिपॉज़िटरी की कॉपी होती है. किसी रिपॉज़िटरी को फ़ॉर्क करने पर, ओरिजनल प्रोजेक्ट पर असर डाले बिना, बदलावों के साथ आज़ादी से प्रयोग किया जा सकता है.

आम तौर पर, फ़ॉर्क का इस्तेमाल किसी दूसरे के प्रोजेक्ट में बदलाव करने के लिए किया जाता है. इसके अलावा, अपने आइडिया को शुरू करने के लिए, किसी दूसरे के प्रोजेक्ट का इस्तेमाल भी किया जा सकता है.

उदाहरण के लिए, किसी गड़बड़ी को ठीक करने से जुड़े बदलावों का सुझाव देने के लिए, फ़ॉर्क का इस्तेमाल किया जा सकता है. किसी गड़बड़ी को ठीक करने के लिए:

रिपॉज़िटरी को फ़ोर्क करें.
गड़बड़ी ठीक करें.
प्रोजेक्ट के मालिक को पुल रिक्वेस्ट सबमिट करें.

सीएफ़टी रिपॉज़िटरी को फ़ॉर्क करने का तरीका:

अपना वेब ब्राउज़र खोलें और terraform-google-modules/terraform-google-cloud-storage रिपॉज़िटरी पर जाएं. हम पूरे कोडलैब के लिए इस रिपॉज़िटरी का इस्तेमाल करेंगे.
पेज के सबसे ऊपर दाएं कोने में, Fork पर क्लिक करें.

आपको एक विकल्प दिखेगा जहां आपको फ़ोर्क रखना है. अपनी प्रोफ़ाइल चुनें और रेपो को फ़ॉर्क कर दिया जाएगा.

अपने फ़ोर्क को स्थानीय तौर पर क्लोन करें

आपका बनाया गया फ़ोर्क, GCS मॉड्यूल रिपॉज़िटरी की कॉपी है. अब आपको अपनी नई सुविधा जोड़ने के लिए, इस रिपॉज़िटरी को अपने लोकल एनवायरमेंट में क्लोन करना होगा.

अपने फ़ोर्क का क्लोन बनाने का तरीका:

अपना वेब ब्राउज़र खोलें और terraform-google-modules/terraform-google-cloud-storage पर जाकर, अपने फ़ॉर्क पर जाएं.
सबसे ऊपर दाएं कोने में, आपको "कोड" बटन दिखेगा. उस पर क्लिक करें.

"कोड" बटन पर क्लिक करने के बाद, फ़ॉर्क का यूआरएल कॉपी करने के लिए, "कॉपी करें" आइकॉन पर क्लिक करें. इस यूआरएल का इस्तेमाल, अपने फ़ोर्क को अपने लोकल एनवायरमेंट में क्लोन करने के लिए किया जाएगा.

अपने VSCode या मशीन में टर्मिनल पर जाएं और फ़ॉर्क को क्लोन करें.

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

अब आपने फ़ॉर्क को लोकल तौर पर क्लोन कर लिया है. अब आपको अपने रिपॉज़िटरी में जाना चाहिए, फ़ॉर्क से एक नई शाखा बनानी चाहिए, और अस्थायी शाखा में कोड में बदलाव करने चाहिए.

नियम के मुताबिक, अपनी शाखा का नाम इस तरह रखा जा सकता है:

सुविधा के अनुरोधों के लिए: feature/feature-name
इंटरनल अपडेट के लिए, internal/change-name
गड़बड़ी ठीक करने के लिए: bugfix/issue-name

एक नई सुविधा जोड़ी जा रही है. इसलिए, अपने अस्थायी ब्रांच 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"

अब आप Cloud Foundation Toolkit पर काम शुरू करने के लिए पूरी तरह सेट अप हैं!

4. टेस्ट एनवायरमेंट बनाना

स्टैंडर्ड सीएफ़टी डेवलपमेंट की प्रोसेस, टेस्टिंग के लिए अलग-अलग टेस्ट प्रोजेक्ट का इस्तेमाल करने पर आधारित होती है. इस चरण में, आपको सेवा खाते की मदद से स्टैंडर्ड कॉन्फ़िगरेशन पर आधारित टेस्ट प्रोजेक्ट बनाने का तरीका बताया जाएगा.

0. Docker Engine इंस्टॉल करें

अगर मशीन का इस्तेमाल डेवलपमेंट के लिए किया जा रहा है, तो आपको Docker Engine इंस्टॉल करना होगा.

1. Google Cloud SDK इंस्टॉल करना

अगर GCP Cloud Shell का इस्तेमाल किया जा रहा है, तो आपको Google Cloud SDK इंस्टॉल करने की ज़रूरत नहीं है.

Google Cloud SDK पर जाएं और अपने प्लैटफ़ॉर्म के लिए इंटरैक्टिव इंस्टॉलर डाउनलोड करें.

2. कॉन्फ़िगरेशन सेट करना

टेस्टिंग एनवायरमेंट बनाने के लिए, आपके पास Google Cloud संगठन, टेस्ट फ़ोल्डर, और बिलिंग खाता होना चाहिए. इन वैल्यू को एनवायरमेंट वैरिएबल की मदद से सेट करना होगा:

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. अपना सेवा खाता सेट अप करना

टेस्टिंग एनवायरमेंट बनाने से पहले, आपको अपने टेस्टिंग एनवायरमेंट में सेवा खाते की कुंजी डाउनलोड करनी होगी. इस सेवा खाते को प्रोजेक्ट क्रिएटर, बिलिंग खाते का उपयोगकर्ता, और संगठन व्यूअर की भूमिकाएं देनी होंगी. इन चरणों की मदद से, नया सेवा खाता बनाया जा सकता है. हालांकि, किसी मौजूदा खाते का फिर से इस्तेमाल भी किया जा सकता है.

3.1 सीड GCP प्रोजेक्ट बनाना या चुनना

अपना सेवा खाता बनाने से पहले, आपको उसे होस्ट करने के लिए कोई प्रोजेक्ट चुनना होगा. आपके पास नया प्रोजेक्ट बनाने का भी विकल्प है.

gcloud config set core/project YOUR_PROJECT_ID

3.2 Google Cloud API चालू करना

अपने सीड प्रोजेक्ट पर, Google Cloud के ये एपीआई चालू करें:

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

3.3 सेवा खाता बनाना

टेस्टिंग एनवायरमेंट को मैनेज करने के लिए, नया सेवा खाता बनाएं:

# 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

पुष्टि करना कि आपका सेवा खाता बनाया गया है:

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

3.4 सेवा खाते को प्रोजेक्ट क्रिएटर, बिलिंग खाते के उपयोगकर्ता, और संगठन दर्शक की भूमिकाएं देना:

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"

अब आपके पास एक सेवा खाता है, जिसका इस्तेमाल टेस्ट एनवायरमेंट को मैनेज करने के लिए किया जा सकता है.

4. Terraform क्रेडेंशियल तैयार करना

टेस्टिंग एनवायरमेंट बनाने के लिए, आपको अपने शेल में सेवा खाते की कुंजी डाउनलोड करनी होगी.

4.1 सेवा खाते की कुंजी

Terraform के लिए सेवा खाता कुंजी बनाना और डाउनलोड करना

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

4.2 Terraform क्रेडेंशियल सेट अप करना

एनवायरमेंट वैरिएबल SERVICE_ACCOUNT_JSON का इस्तेमाल करके, Terraform को कुंजी दें. इसके लिए, वैल्यू को अपने सेवा खाते की कुंजी के कॉन्टेंट पर सेट करें.

export SERVICE_ACCOUNT_JSON=$(< cft.json)

एनवायरमेंट वैरिएबल में क्रेडेंशियल की जानकारी सेव करने के बाद, पासकोड वाली फ़ाइल हटाएं. ज़रूरत पड़ने पर, ऊपर दिए गए निर्देश का इस्तेमाल करके, बाद में भी पासकोड फिर से बनाया जा सकता है.

rm -rf cft.json

5. Terraform डिप्लॉयमेंट के लिए टेस्ट प्रोजेक्ट बनाना

अब जब सब कुछ तैयार हो गया है, तो एक ही निर्देश से टेस्ट प्रोजेक्ट बनाया जा सकता है. terraform-google-cloud-storage डायरेक्ट्री के रूट से यह कमांड चलाएं:

make docker_test_prepare

make docker_test_prepare चलाने पर, आपको नीचे दिया गया आउटपुट दिखेगा. आखिर में, आपको टेस्ट के लिए बनाया गया project_id मिलेगा. यहां आपको अपनी नई सुविधा के साथ Cloud Storage मॉड्यूल को डिप्लॉय और टेस्ट करना होगा. अगर आपको बिलिंग खाता लिंक करने में समस्याएं आ रही हैं, तो समस्या हल करने का तरीका देखें.

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.

अब आपने एक टेस्ट प्रोजेक्ट बना लिया है, जिसका रेफ़रंस project_id है. इसे कंसोल आउटपुट में देखा जा सकता है. आपका डेवलपमेंट और टेस्ट एनवायरमेंट सेट अप हो गया है.

5. सीएफ़टी मॉड्यूल में नई सुविधा जोड़ें

अब आपका डेवलपमेंट और टेस्ट एनवायरमेंट सेट अप हो गया है. अब google-cloud-storage CFT मॉड्यूल में अपनी "silly_label" सुविधा जोड़ना शुरू करें.

पक्का करें कि आप terraform-google-cloud-storage में हों और main.tf फ़ाइल को खोलें, जैसा कि फ़ोल्डर स्ट्रक्चर में नीचे दिखाया गया है.

"silly_label" एक लेबल है. इसलिए, आपको Main.tf में "labels" वैरिएबल में, लाइन 27 में सुविधा को जोड़ना होगा, जैसा कि यहां दिखाया गया है:

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

अब आपको ऊपर दिए गए फ़ोल्डर स्ट्रक्चर में दिखने वाले variables.tf में silly_label वैरिएबल जोड़ना होगा.

नीचे दिए गए कोड को कॉपी करके, variables.tf में लाइन 31 पर चिपकाएं. साथ ही, पक्का करें कि आपने जो वैरिएबल ब्लॉक जोड़ा है उसके ऊपर और नीचे, एक नई लाइन का वर्ण हो.

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. स्टोरेज बकेट के उदाहरण में नई सुविधा जोड़ना

आपने अपनी सुविधा को मॉड्यूल के key.tf में जोड़ दिया है और अब आप एक उदाहरण के ज़रिए, जोड़ी गई सुविधा की जांच करेंगे.

"silly_label" को examples/multiple-buckets/main.tf में जोड़ना होगा

अगले चरण में इंटिग्रेशन टेस्ट करने के लिए, इस उदाहरण का इस्तेमाल किया जाएगा.

नीचे दी गई वैरिएबल silly_label लाइन को कॉपी करके, item.tf में लाइन 27 पर चिपकाएं. यहां आपको terraform-google-cloud-storage/examples/multiple-buckets/ जैसा कुछ फ़ोल्डर में बताया गया है:

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. सुविधा की जांच करने के लिए, ब्लूप्रिंट टेस्ट अपडेट करना

आपने अपनी सुविधा को मॉड्यूल के main.tf में जोड़ा है और फिर multiple_buckets उदाहरण में सुविधा जोड़ी है. अब आपको अपनी सुविधा को Golang में लिखे गए ब्लूप्रिंट इंटिग्रेशन टेस्ट के ज़रिए टेस्ट करना होगा.

आप अपनी नई जांच को यहां दिए गए फ़ोल्डर स्ट्रक्चर में मौजूद Multi_buckets_test.go फ़ाइल में जोड़ेंगे:

आपने Multi_buckets मॉड्यूल के ज़रिए बनाई जा रही सभी बकेट पर "silly_label" जोड़ दिया हो. अब आपको नई सुविधा को टेस्ट करने के लिए टेस्ट लिखना होगा.

नीचे दिए गए कोड में, आपको gcloud alpha storage कमांड की मदद से हर बकेट का लेबल मिल रहा है. इसके बाद, कमांड से मिला आउटपुट देखा जा रहा है.

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. सीएफ़टी में इंटिग्रेशन टेस्ट चलाना

इंटिग्रेशन टेस्टिंग

इंटिग्रेशन टेस्ट का इस्तेमाल, रूट मॉड्यूल, सब-मॉड्यूल, और उदाहरणों के व्यवहार की पुष्टि करने के लिए किया जाता है. जोड़ने, बदलाव करने, और गड़बड़ियों को ठीक करने के साथ-साथ टेस्ट भी किए जाने चाहिए.

इंटिग्रेशन टेस्ट, ब्लूप्रिंट टेस्ट फ़्रेमवर्क का इस्तेमाल करके लिखे जाते हैं और CFT सीएलआई का इस्तेमाल करके चलाए जाते हैं. इन टूल को आसानी से इस्तेमाल करने के लिए, Docker इमेज में पैकेज किया जाता है.

इन टेस्ट के लिए, आम तौर पर उदाहरण के तौर पर दिए गए मॉड्यूल के काम करने के तरीके की पुष्टि की जाती है. इससे यह पक्का किया जाता है कि रूट मॉड्यूल, सब-मॉड्यूल, और उदाहरण के तौर पर दिए गए मॉड्यूल, सभी सही तरीके से काम कर रहे हैं.

इंटरैक्टिव एक्ज़ीक्यूशन में, हर चरण को एक से ज़्यादा निर्देशों की मदद से एक्ज़ीक्यूट किया जाता है.

इंटरैक्टिव मोड में टेस्टिंग Docker कंटेनर शुरू करने के लिए, make docker_run चलाएं.

Make एक बिल्ड ऑटोमेशन टूल है. यह Makefiles नाम की फ़ाइलों को पढ़कर, सोर्स कोड से अपने-आप प्रोग्राम और लाइब्रेरी बनाता है. इन फ़ाइलों से यह पता चलता है कि टारगेट प्रोग्राम को कैसे बनाया जाए. फ़ाइल में बदलाव करने पर, Docker कंटेनर अपने-आप अपडेट हो जाना चाहिए.

make docker_run को चलाने पर, आपके पास अपने डॉकर कंटेनर में वर्कस्पेस बनाने और अपने सेवा खाते के क्रेडेंशियल चालू करने का विकल्प होता है. अगले चरण में, टेस्ट करने के लिए फ़ाइल फ़ोल्डर का इस्तेमाल किया जाएगा.

आपको अपने टर्मिनल में यह आउटपुट दिखेगा:

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

अपने फ़ाइल फ़ोल्डर में सभी ब्लूप्रिंट टेस्ट की सूची बनाने के लिए cft test list चलाएं.

आपको अपने टर्मिनल में यह आउटपुट दिखेगा:

[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

उदाहरण शुरू करने के लिए, cft test run <EXAMPLE_NAME> --stage init चलाएं. इस मामले में, TestMultipleBuckets टेस्ट रन को शुरू करने के लिए, cft test run TestMultipleBuckets --stage init. टेस्ट चलाते समय ज़्यादा जानकारी पाने के लिए, --verbose फ़्लैग का भी इस्तेमाल किया जा सकता है.

यह इनिट स्टेज, टेराफ़ॉर्म के उदाहरण को शुरू करता है.

आपको अपने टर्मिनल में यह आउटपुट दिखेगा.

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

उदाहरण के तौर पर दिया गया मॉड्यूल लागू करने के लिए, cft test run <EXAMPLE_NAME> --stage apply चलाएं.

इस चरण में, पिछले चरण में शुरू किए गए उदाहरण को कोडलैब में पहले से बनाए गए GCP प्रोजेक्ट पर लागू किया जाता है.

आपको अपने टर्मिनल में यह आउटपुट दिखेगा.

[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

cft test run <EXAMPLE_NAME> --stage verify चलाकर पुष्टि करें कि उदाहरण में उम्मीद के मुताबिक इंफ़्रास्ट्रक्चर बनाया गया है.

इस चरण में, TestMultipleBuckets में पुष्टि करने वाला फ़ंक्शन चलेगा. आम तौर पर, किसी संसाधन की मौजूदा स्थिति का JSON आउटपुट पाने के लिए, gcloud कमांड का इस्तेमाल करके पुष्टि की जाती है. साथ ही, यह भी पक्का किया जाता है कि मौजूदा स्थिति, उदाहरण में बताई गई स्थिति जैसी ही है.

अगर आपको कोई गड़बड़ी मिलती है, तो आपको यह दिखेगा कि जांच के लिए कमांड से क्या मिला और क्या उम्मीद थी.

आपको अपने टर्मिनल में यह आउटपुट दिखेगा.

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

उदाहरण को हटाने के लिए, cft test run <EXAMPLE_NAME> --stage teardown चलाएं.

इस चरण में, ऊपर दिए गए चरणों में बनाया गया इंफ़्रास्ट्रक्चर मिटा दिया जाता है. ऐसा करने पर, प्रोजेक्ट में बनाई गई GCS बकेट भी मिट जाएंगी. साथ ही, GCS मॉड्यूल में जोड़ा गया लेबल भी मिट जाएगा.

अपने टर्मिनल में नीचे दिया गया आउटपुट देखा जा सकता है.

[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

टेस्ट कंटेनर से बाहर निकलने के लिए, exit चलाएं.

9. इनपुट और आउटपुट के लिए दस्तावेज़ जनरेट करना

रूट मॉड्यूल, सबमॉड्यूल, और उदाहरण मॉड्यूल के README में इनपुट और आउटपुट टेबल, उनसे जुड़े मॉड्यूल के variables और outputs के आधार पर अपने-आप जनरेट होते हैं. मॉड्यूल इंटरफ़ेस में बदलाव होने पर, इन टेबल को रीफ़्रेश करना ज़रूरी है.

चलाएं:

make generate_docs
# This will generate new Inputs and Outputs tables

10. CFT में लिंट टेस्ट चलाना

लिंटर एक ऐसा टूल है जो प्रोग्रामिंग गड़बड़ियों, गड़बड़ियों, स्टाइल से जुड़ी गड़बड़ियों, और संदिग्ध कॉन्स्ट्रक्ट को फ़्लैग करने के लिए, सोर्स कोड का विश्लेषण करता है.

डेटा स्टोर करने की जगह में मौजूद कई फ़ाइलों को क्वालिटी बनाए रखने के लिए, लिंट किया जा सकता है या उनका फ़ॉर्मैट बदला जा सकता है. सीएफ़टी की क्वालिटी पक्का करने के लिए, लिंट टेस्ट का इस्तेमाल करें.

चलाएं:

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

11. GitHub पर पीआर सबमिट करना

अब आपने अपने कोड में बदलाव कर लिया है और इंटिग्रेशन टेस्ट की मदद से उसकी जांच कर ली है. अब आपको इस कोड को मास्टर रिपॉज़िटरी में पब्लिश करना होगा.

अपने कोड को मास्टर रिपॉज़िटरी पर उपलब्ध कराने के लिए, आपको अपनी शाखा में कोड में किए गए बदलावों को कमिट करना होगा और उसे मास्टर रिपॉज़िटरी में पुश करना होगा. Codelab की शुरुआत में फ़ॉर्क किए गए मुख्य रिपॉज़िटरी में अपना कोड जोड़ने के लिए, आपको अपने रिपॉज़िटरी में कोड को कमिट करने के बाद, मुख्य रिपॉज़िटरी पर एक पुलब्सिस्ट (पीआर) सबमिट करना होगा.

पीआर सबमिट करने पर, कोड में किए गए सुझाए गए बदलावों की समीक्षा करने के लिए, रिपॉज़िटरी एडमिन को सूचना दी जाएगी. इसके अलावा, कोड में किए गए बदलावों के बारे में सुझाव, राय या शिकायत पाने के लिए, अन्य उपयोगकर्ताओं को समीक्षक के तौर पर भी जोड़ा जा सकता है. इस पीआर से Cloud Build ट्रिगर होगा, जो रिपॉज़िटरी पर टेस्ट चलाएगा.

आपके कोड में होने वाले बदलावों के आधार पर, कोड समीक्षक आपके कोड पर टिप्पणियां देंगे. साथ ही, अगर सबसे सही तरीकों और दस्तावेज़ के आधार पर किसी बदलाव की ज़रूरत है, तो कोड में बदलाव करने के लिए कहेंगे. एडमिन आपके कोड में किए गए बदलावों की समीक्षा करेगा और यह पक्का करेगा कि आपका कोड, रेपो के नियमों का पालन करता हो. साथ ही, आपके कोड को मास्टर रेपो में मर्ज करने से पहले, एडमिन आपसे कुछ बदलाव करने का अनुरोध कर सकता है.

फ़ॉर्क की गई शाखा में कोड को कमिट करने और उसमें कोड को पुश करने के लिए, यह तरीका अपनाएं:

सबसे पहले, बदली गई फ़ाइलें लोकल रेपो में जोड़ें.

$ 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

आपकी फ़ाइलें अब स्टेज हो गई हैं. इसके बाद, आपको बदलावों को लागू करना होगा.

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

पुल का अनुरोध (पीआर) बनाने के लिए, अपने लोकल डेटा स्टोर करने की जगह में किए गए बदलावों को GitHub में भेजें.

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

कोड में किए गए आपके बदलाव, अब पुल रिक्वेस्ट के लिए तैयार हैं!

terraform-google-modules/terraform-google-cloud-storage रिपो में पीआर बनाने के लिए, यह तरीका अपनाएं:

अपने वेब ब्राउज़र में, रिपो के मुख्य पेज पर जाएं.
आपको अपने फ़ोर्क से पीआर खोलने के लिए बैनर में एक सुझाव दिखेगा. "तुलना करें और पुश अनुरोध करें" पर क्लिक करें.

कोड में किए गए बदलावों के बारे में बताने के लिए, अपने पुल रिक्वेस्ट का टाइटल और ब्यौरा डालें. कम से कम शब्दों में ज़्यादा से ज़्यादा सटीक जानकारी दें.

समीक्षा के लिए तैयार पुल अनुरोध बनाने के लिए, "पुल अनुरोध बनाएं" पर क्लिक करें.
आपको ऐसे Cloud Build ट्रिगर दिखेंगे जो PR की वजह से ट्रिगर हुए हैं.
अगर आपको कोई समस्या आती है, तो फ़ॉर्क से पुल के अनुरोध करने के बारे में GitHub के आधिकारिक दस्तावेज़ देखें.

आपने कोड में किए गए पहले बदलाव को मुख्य ब्रांच में बदल दिया और अपने पहले सीएफ़टी पीआर को मास्टर ब्रांच में बदल दिया!

12. बधाई हो

बधाई हो, आपने CFT मॉड्यूल में एक सुविधा जोड़ दी है और समीक्षा के लिए एक पीआर सबमिट कर दिया है!

आपने CFT मॉड्यूल में कोई सुविधा जोड़ी है, किसी उदाहरण की मदद से स्थानीय तौर पर उसकी जांच की है, और GitHub पर अपना कोड कमिट करने से पहले उसकी जांच की है. आखिर में, समीक्षा और CFT में फ़ाइनल मर्ज के लिए, आपने एक पीआर किया.

अब आपको Cloud Foundation टूलकिट का इस्तेमाल शुरू करने के ज़रूरी चरणों के बारे में पता है.