🥇मुर्गी या अंडा: IaC को विभाजित करना

पहले क्या आया था, मुर्गी या अंडा? इंफ्रास्ट्रक्चर-एज़-कोड के बारे में एक लेख की शुरुआत काफी अजीब है, है ना?

अंडा क्या है?

अक्सर, इंफ्रास्ट्रक्चर-एज़-कोड (IaC) बुनियादी ढांचे का प्रतिनिधित्व करने का एक घोषणात्मक तरीका है। इसमें हम उस स्थिति का वर्णन करते हैं जिसे हम हासिल करना चाहते हैं, हार्डवेयर भाग से शुरू होकर सॉफ़्टवेयर कॉन्फ़िगरेशन तक। इसलिए IaC का उपयोग इसके लिए किया जाता है:

संसाधन प्रावधान. ये वीएम, एस3, वीपीसी आदि हैं। काम के लिए बुनियादी उपकरण: terraform и बादल निर्माण.
सॉफ्टवेयर विन्यास. बुनियादी उपकरण: Ansible, बावर्ची, आदि।

कोई भी कोड git रिपॉजिटरी में है। और देर-सबेर टीम लीडर यह निर्णय लेगा कि उन्हें व्यवस्थित करने की आवश्यकता है। और वह रिफैक्टर करेगा. और यह कुछ संरचना तैयार करेगा. और वह देखेगा कि यह अच्छा है।

यह भी अच्छा है कि यह पहले से ही मौजूद है GitLab и GitHub-टेराफॉर्म के लिए प्रदाता (और यह सॉफ्टवेयर कॉन्फ़िगरेशन है)। उनकी मदद से, आप पूरे प्रोजेक्ट का प्रबंधन कर सकते हैं: टीम के सदस्य, सीआई/सीडी, गिट-फ्लो, आदि।

अंडा कहां से आया?

इसलिए हम धीरे-धीरे मुख्य प्रश्न पर पहुँच रहे हैं।

सबसे पहले, आपको एक रिपॉजिटरी से शुरुआत करनी होगी जो आपके सहित अन्य रिपॉजिटरी की संरचना का वर्णन करती है। और निश्चित रूप से, GitOps के भाग के रूप में, आपको CI जोड़ने की आवश्यकता है ताकि परिवर्तन स्वचालित रूप से निष्पादित हो जाएं।

यदि Git अभी तक नहीं बनाया गया है?

इसे Git में कैसे स्टोर करें?
सीआई कैसे स्थापित करें?
यदि हम IaC का उपयोग करके और यहां तक कि Kubernetes में भी Gitlab को तैनात करें?
और गिटलैब रनर भी कुबेरनेट्स में?
क्लाउड प्रदाता में कुबेरनेट्स के बारे में क्या?

सबसे पहले क्या आया: GitLab जहां मैं अपना कोड अपलोड करूंगा, या वह कोड जो बताता है कि मुझे किस प्रकार के GitLab की आवश्यकता है?

अंडे के साथ चिकन

«ओयाकोडोन3 एक डायनासोर के साथ" ["]

आइए क्लाउड प्रदाता के रूप में एक व्यंजन पकाने का प्रयास करें प्रबंधित कुबेरनेट्स सेलेक्टेल.

TL, डॉ

क्या एक बार में एक टीम में शामिल होना संभव है?

$ export MY_SELECTEL_TOKEN=<token>
$ curl https://gitlab.com/chicken-or-egg/mks/make/-/snippets/2002106/raw | bash

सामग्री:

My.selectel.ru से खाता;
खाता टोकन;
कुबेरनेट्स कौशल;
हेल्म कौशल;
टेराफ़ॉर्म कौशल;
हेल्म चार्ट गिटलैब;
हेल्म चार्ट गिटलैब रनर।

पकाने की विधि:

पैनल से MY_SELECTEL_TOKEN प्राप्त करें my.selectel.ru.
इसमें एक खाता टोकन स्थानांतरित करके कुबेरनेट्स क्लस्टर बनाएं।
निर्मित क्लस्टर से KUBECONFIG प्राप्त करें।
कुबेरनेट्स पर GitLab स्थापित करें।
उपयोगकर्ता के लिए बनाए गए GitLab से GitLab-टोकन प्राप्त करें जड़.
GitLab-टोकन का उपयोग करके GitLab में एक प्रोजेक्ट संरचना बनाएं।
मौजूदा कोड को GitLab पर पुश करें।
?
लाभ!

1 कदम. टोकन अनुभाग में प्राप्त किया जा सकता है एपीआई कुंजी.

2 कदम. हम 2 नोड्स के समूह को "बेकिंग" के लिए अपना टेराफॉर्म तैयार करते हैं। यदि आप आश्वस्त हैं कि आपके पास हर चीज़ के लिए पर्याप्त संसाधन हैं, तो आप ऑटो कोटा सक्षम कर सकते हैं:

provider "selectel" {
 token = var.my_selectel_token
}

variable "my_selectel_token" {}
variable "username" {}
variable "region" {}


resource "selectel_vpc_project_v2" "my-k8s" {
 name = "my-k8s-cluster"
 theme = {
   color = "269926"
 }
 quotas {
   resource_name = "compute_cores"
   resource_quotas {
     region = var.region
     zone = "${var.region}a"
     value = 16
   }
 }
 quotas {
   resource_name = "network_floatingips"
   resource_quotas {
     region = var.region
     value = 1
   }
 }
 quotas {
   resource_name = "load_balancers"
   resource_quotas {
     region = var.region
     value = 1
   }
 }
 quotas {
   resource_name = "compute_ram"
   resource_quotas {
     region = var.region
     zone = "${var.region}a"
     value = 32768
   }
 }
 quotas {
   resource_name = "volume_gigabytes_fast"
   resource_quotas {
     region = var.region
     zone = "${var.region}a"
     # (20 * 2) + 50 + (8 * 3 + 10)
     value = 130
   }
 }
}

resource "selectel_mks_cluster_v1" "k8s-cluster" {
 name         = "k8s-cluster"
 project_id   = selectel_vpc_project_v2.my-k8s.id
 region       = var.region
 kube_version = "1.17.9"
}

resource "selectel_mks_nodegroup_v1" "nodegroup_1" {
 cluster_id        = selectel_mks_cluster_v1.k8s-cluster.id
 project_id        = selectel_mks_cluster_v1.k8s-cluster.project_id
 region            = selectel_mks_cluster_v1.k8s-cluster.region
 availability_zone = "${var.region}a"
 nodes_count       = 2
 cpus              = 8
 ram_mb            = 16384
 volume_gb         = 15
 volume_type       = "fast.${var.region}a"
 labels            = {
   "project": "my",
 }
}

प्रोजेक्ट में एक उपयोगकर्ता जोड़ें:

resource "random_password" "my-k8s-user-pass" {
 length = 16
 special = true
 override_special = "_%@"
}

resource "selectel_vpc_user_v2" "my-k8s-user" {
 password = random_password.my-k8s-user-pass.result
 name = var.username
 enabled  = true
}

resource "selectel_vpc_keypair_v2" "my-k8s-user-ssh" {
 public_key = file("~/.ssh/id_rsa.pub")
 user_id    = selectel_vpc_user_v2.my-k8s-user.id
 name = var.username
}

resource "selectel_vpc_role_v2" "my-k8s-role" {
 project_id = selectel_vpc_project_v2.my-k8s.id
 user_id    = selectel_vpc_user_v2.my-k8s-user.id
}

आउटपुट:

output "project_id" {
 value = selectel_vpc_project_v2.my-k8s.id
}

output "k8s_id" {
 value = selectel_mks_cluster_v1.k8s-cluster.id
}

output "user_name" {
 value = selectel_vpc_user_v2.my-k8s-user.name
}

output "user_pass" {
 value = selectel_vpc_user_v2.my-k8s-user.password
}

आइए लॉन्च करें:

$ env 
TF_VAR_region=ru-3 
TF_VAR_username=diamon 
TF_VAR_my_selectel_token=<token> 
terraform plan -out planfile

$ terraform apply -input=false -auto-approve planfile

3 कदम. हमें क्यूबकॉन्फिग मिलता है।

KUBECONFIG को प्रोग्रामेटिक रूप से डाउनलोड करने के लिए, आपको ओपनस्टैक से एक टोकन प्राप्त करना होगा:

openstack token issue -c id -f value > token

और इस टोकन के साथ प्रबंधित कुबेरनेट्स सेलेक्टेल एपीआई के लिए अनुरोध करें। k8s_id बाहर देता है terraform:

curl -XGET -H "x-auth-token: $(cat token)" "https://ru-3.mks.selcloud.ru/v1/clusters/$(cat k8s_id)/kubeconfig" -o kubeConfig.yaml

Cupconfig को पैनल के माध्यम से भी एक्सेस किया जा सकता है।

4 कदम. क्लस्टर के पक जाने के बाद और हमारे पास उस तक पहुंच होने के बाद, हम स्वाद के लिए ऊपर से रतालू डाल सकते हैं।

मैं जोड़ना पसंद करता हूं:

नाम स्थान,
भंडारण वर्ग
पॉड सुरक्षा नीति इत्यादि।

भंडारण कक्षा सेलेक्टेल के लिए लिया जा सकता है आधिकारिक भंडार.

चूँकि प्रारंभ में मैंने ज़ोन में एक क्लस्टर का चयन किया था आरयू-3ए, तो मुझे इस क्षेत्र से स्टोरेज क्लास की आवश्यकता है।

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
 name: fast.ru-3a
 annotations:
   storageclass.kubernetes.io/is-default-class: "true"
provisioner: cinder.csi.openstack.org
parameters:
 type: fast.ru-3a
 availability: ru-3a
allowVolumeExpansion: true

5 कदम. एक लोड बैलेंसर स्थापित करें.

हम कई लोगों के लिए मानक एक का उपयोग करेंगे nginx-प्रवेश. इसे स्थापित करने के लिए पहले से ही बहुत सारे निर्देश मौजूद हैं, इसलिए हम इस पर ध्यान नहीं देंगे।

$ helm repo add nginx-stable https://helm.nginx.com/stable
$ helm upgrade nginx-ingress nginx-stable/nginx-ingress -n ingress --install -f ../internal/K8S-cluster/ingress/values.yml

हम लगभग 3-4 मिनट तक बाहरी आईपी प्राप्त होने की प्रतीक्षा करते हैं:

प्राप्त बाहरी आईपी:

6 कदम. गिटलैब स्थापित करें.

$ helm repo add gitlab https://charts.gitlab.io
$ helm upgrade gitlab gitlab/gitlab -n gitlab  --install -f gitlab/values.yml --set "global.hosts.domain=gitlab.$EXTERNAL_IP.nip.io"

हम फिर से सभी फलियों के उगने का इंतजार करते हैं।

kubectl get po -n gitlab
NAME                                      	READY   STATUS  	RESTARTS   AGE
gitlab-gitaly-0                           	0/1 	Pending 	0      	0s
gitlab-gitlab-exporter-88f6cc8c4-fl52d    	0/1 	Pending 	0      	0s
gitlab-gitlab-runner-6b6867c5cf-hd9dp     	0/1 	Pending 	0      	0s
gitlab-gitlab-shell-55cb6ccdb-h5g8x       	0/1 	Init:0/2	0      	0s
gitlab-migrations.1-2cg6n                 	0/1 	Pending 	0      	0s
gitlab-minio-6dd7d96ddb-zd9j6             	0/1 	Pending 	0      	0s
gitlab-minio-create-buckets.1-bncdp       	0/1 	Pending 	0      	0s
gitlab-postgresql-0                       	0/2 	Pending 	0      	0s
gitlab-prometheus-server-6cfb57f575-v8k6j 	0/2 	Pending 	0      	0s
gitlab-redis-master-0                     	0/2 	Pending 	0      	0s
gitlab-registry-6bd77b4b8c-pb9v9          	0/1 	Pending 	0      	0s
gitlab-registry-6bd77b4b8c-zgb6r          	0/1 	Init:0/2	0      	0s
gitlab-shared-secrets.1-pc7-5jgq4         	0/1 	Completed   0      	20s
gitlab-sidekiq-all-in-1-v1-54dbcf7f5f-qbq67   0/1 	Pending 	0      	0s
gitlab-task-runner-6fd6857db7-9x567       	0/1 	Pending 	0      	0s
gitlab-webservice-d9d4fcff8-hp8wl         	0/2 	Pending 	0      	0s
Waiting gitlab
./wait_gitlab.sh ../internal/gitlab/gitlab/.pods
waiting for pod...
waiting for pod...
waiting for pod...

फलियाँ उग आईं:

7 कदम. हमें GitLab-टोकन प्राप्त होता है।

सबसे पहले, लॉगिन पासवर्ड पता करें:

kubectl get secret -n gitlab gitlab-gitlab-initial-root-password -o jsonpath='{.data.password}' | base64 --decode

अब लॉग इन करें और टोकन प्राप्त करें:

python3 get_gitlab_token.py root $GITLAB_PASSWORD http://gitlab.gitlab.$EXTERNAL_IP.nip.io

8 कदम. Gitlab प्रदाता का उपयोग करके Git रिपॉजिटरी को सही पदानुक्रम में लाना।

cd ../internal/gitlab/hierarchy && terraform apply -input=false -auto-approve planfile

दुर्भाग्य से, टेराफॉर्म गिटलैब प्रदाता के पास फ्लोटिंग है बग. फिर आपको tf.state को ठीक करने के लिए परस्पर विरोधी परियोजनाओं को मैन्युअल रूप से हटाना होगा। फिर कमांड `$मेक ऑल` को दोबारा चलाएँ

9 कदम. हम स्थानीय रिपॉजिटरी को सर्वर पर स्थानांतरित करते हैं।

$ make push

[master (root-commit) b61d977]  Initial commit
 3 files changed, 46 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 values.yml
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
Compressing objects: 100% (5/5), done.
Writing objects: 100% (5/5), 770 bytes | 770.00 KiB/s, done.
Total 5 (delta 0), reused 0 (delta 0)

समाप्त:

निष्कर्ष

हमने यह हासिल कर लिया है कि हम अपनी स्थानीय मशीन से हर चीज़ को घोषणात्मक रूप से प्रबंधित कर सकते हैं। अब मैं इन सभी कार्यों को सीआई में स्थानांतरित करना चाहता हूं और बस बटन दबाना चाहता हूं। ऐसा करने के लिए, हमें अपने स्थानीय राज्यों (टेराफॉर्म राज्य) को सीआई में स्थानांतरित करना होगा। यह कैसे करें यह अगले भाग में है।

हमारी सदस्यता लें ब्लॉगताकि नए लेखों के विमोचन से न चूकें!

स्रोत: www.habr.com

मुर्गी या अंडा: IaC को विभाजित करना