ਚਿਕਨ ਜਾਂ ਅੰਡੇ: IaC ਨੂੰ ਵੰਡਣਾ

ਪਹਿਲਾਂ ਕੀ ਆਇਆ - ਚਿਕਨ ਜਾਂ ਅੰਡੇ? ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਰੂਪ ਵਿੱਚ-ਕੋਡ ਬਾਰੇ ਇੱਕ ਲੇਖ ਲਈ ਇੱਕ ਅਜੀਬ ਸ਼ੁਰੂਆਤ, ਹੈ ਨਾ?

ਅੰਡੇ ਕੀ ਹੈ?

ਬਹੁਤੇ ਅਕਸਰ, ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਰੂਪ ਵਿੱਚ-ਕੋਡ (IaC) ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਨੁਮਾਇੰਦਗੀ ਕਰਨ ਦਾ ਇੱਕ ਘੋਸ਼ਣਾਤਮਕ ਤਰੀਕਾ ਹੁੰਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਅਸੀਂ ਉਸ ਸਥਿਤੀ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਾਂ ਜੋ ਅਸੀਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਹਾਰਡਵੇਅਰ ਹਿੱਸੇ ਤੋਂ ਸ਼ੁਰੂ ਹੋ ਕੇ ਅਤੇ ਸੌਫਟਵੇਅਰ ਸੰਰਚਨਾ ਦੇ ਨਾਲ ਖਤਮ ਹੁੰਦਾ ਹੈ। ਇਸ ਲਈ IaC ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ:

1. ਸਰੋਤ ਪ੍ਰਬੰਧ। ਇਹ VM, S3, VPC, ਆਦਿ ਹਨ। ਕੰਮ ਲਈ ਬੁਨਿਆਦੀ ਸਾਧਨ: ਟੈਰਾਫਾਰਮ и ਕਲਾਉਡ ਫਾਰਮੇਸ਼ਨ.
2. ਸਾਫਟਵੇਅਰ ਕੌਨਫਿਗਰੇਸ਼ਨ. ਬੁਨਿਆਦੀ ਸੰਦ: Ansimate, ਸ਼ੈੱਫ, ਆਦਿ।

ਕੋਈ ਵੀ ਕੋਡ git ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ ਹੁੰਦਾ ਹੈ। ਅਤੇ ਜਲਦੀ ਜਾਂ ਬਾਅਦ ਵਿੱਚ ਟੀਮ ਲੀਡਰ ਇਹ ਫੈਸਲਾ ਕਰੇਗਾ ਕਿ ਉਹਨਾਂ ਨੂੰ ਕ੍ਰਮ ਵਿੱਚ ਰੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਅਤੇ ਉਹ ਰੀਫੈਕਟਰ ਕਰੇਗਾ. ਅਤੇ ਇਹ ਕੁਝ ਢਾਂਚਾ ਬਣਾਏਗਾ। ਅਤੇ ਉਹ ਦੇਖੇਗਾ ਕਿ ਇਹ ਚੰਗਾ ਹੈ।

ਇਹ ਵੀ ਚੰਗਾ ਹੈ ਕਿ ਇਹ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ GitLab и GitHub-ਟੇਰਾਫਾਰਮ ਲਈ ਪ੍ਰਦਾਤਾ (ਅਤੇ ਇਹ ਸਾਫਟਵੇਅਰ ਸੰਰਚਨਾ ਹੈ)। ਉਹਨਾਂ ਦੀ ਮਦਦ ਨਾਲ, ਤੁਸੀਂ ਪੂਰੇ ਪ੍ਰੋਜੈਕਟ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰ ਸਕਦੇ ਹੋ: ਟੀਮ ਦੇ ਮੈਂਬਰ, CI/CD, git-flow, ਆਦਿ।

ਆਂਡਾ ਕਿੱਥੋਂ ਆਇਆ?

ਇਸ ਲਈ ਅਸੀਂ ਹੌਲੀ-ਹੌਲੀ ਮੁੱਖ ਸਵਾਲ ਦੇ ਨੇੜੇ ਆ ਰਹੇ ਹਾਂ।

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜੋ ਤੁਹਾਡੇ ਸਮੇਤ ਹੋਰ ਰਿਪੋਜ਼ਟਰੀਆਂ ਦੀ ਬਣਤਰ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ। ਅਤੇ ਬੇਸ਼ੱਕ, GitOps ਦੇ ਹਿੱਸੇ ਵਜੋਂ, ਤੁਹਾਨੂੰ CI ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੋ ਤਬਦੀਲੀਆਂ ਆਪਣੇ ਆਪ ਹੀ ਲਾਗੂ ਹੋ ਜਾਣ।

ਜੇਕਰ Git ਅਜੇ ਤੱਕ ਨਹੀਂ ਬਣਾਇਆ ਗਿਆ ਹੈ?

1. ਇਸਨੂੰ Git ਵਿੱਚ ਕਿਵੇਂ ਸਟੋਰ ਕਰਨਾ ਹੈ?
2. CI ਨੂੰ ਕਿਵੇਂ ਇੰਸਟਾਲ ਕਰਨਾ ਹੈ?
3. ਜੇ ਅਸੀਂ ਆਈਏਸੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗਿਟਲੈਬ ਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਵੀ?
4. ਅਤੇ ਗਿਟਲੈਬ ਰਨਰ ਵੀ ਕੁਬਰਨੇਟਸ ਵਿੱਚ?
5. ਕਲਾਉਡ ਪ੍ਰਦਾਤਾ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਬਾਰੇ ਕੀ?

ਪਹਿਲਾਂ ਕੀ ਆਇਆ: GitLab ਜਿੱਥੇ ਮੈਂ ਆਪਣਾ ਕੋਡ ਅੱਪਲੋਡ ਕਰਾਂਗਾ, ਜਾਂ ਕੋਡ ਜੋ ਦੱਸਦਾ ਹੈ ਕਿ ਮੈਨੂੰ ਕਿਸ ਕਿਸਮ ਦੀ GitLab ਦੀ ਲੋੜ ਹੈ?

ਅੰਡੇ ਦੇ ਨਾਲ ਚਿਕਨ

«ਓਯਾਕੋਡੋਨ3 ਡਾਇਨਾਸੌਰ ਨਾਲ" [ਝਰੋਖੇ]

ਆਉ ਕਲਾਉਡ ਪ੍ਰਦਾਤਾ ਵਜੋਂ ਵਰਤਦੇ ਹੋਏ ਇੱਕ ਡਿਸ਼ ਪਕਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਪ੍ਰਬੰਧਿਤ Kubernetes Selectel.

TL; ਡਾ

ਕੀ ਇੱਕੋ ਸਮੇਂ ਇੱਕ ਟੀਮ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣਾ ਸੰਭਵ ਹੈ?

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

ਸਮੱਗਰੀ:

• my.selectel.ru ਤੋਂ ਖਾਤਾ;
• ਖਾਤਾ ਟੋਕਨ;
• ਕੁਬਰਨੇਟਸ ਦੇ ਹੁਨਰ;
• ਹੈਲਮ ਹੁਨਰ;
• ਟੈਰਾਫਾਰਮ ਹੁਨਰ;
• ਹੈਲਮ ਚਾਰਟ GitLab;
• ਹੈਲਮ ਚਾਰਟ ਗਿੱਟਲੈਬ ਰਨਰ।

ਵਿਅੰਜਨ:

1. ਪੈਨਲ ਤੋਂ MY_SELECTEL_TOKEN ਪ੍ਰਾਪਤ ਕਰੋ my.selectel.ru.
2. ਇਸ ਵਿੱਚ ਇੱਕ ਖਾਤਾ ਟੋਕਨ ਟ੍ਰਾਂਸਫਰ ਕਰਕੇ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਬਣਾਓ।
3. ਬਣਾਏ ਗਏ ਕਲੱਸਟਰ ਤੋਂ KUBECONFIG ਪ੍ਰਾਪਤ ਕਰੋ।
4. Kubernetes 'ਤੇ GitLab ਇੰਸਟਾਲ ਕਰੋ।
5. ਉਪਭੋਗਤਾ ਲਈ ਬਣਾਈ ਗਈ GitLab ਤੋਂ GitLab-ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰੋ ਰੂਟ.
6. GitLab-ਟੋਕਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ GitLab ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਢਾਂਚਾ ਬਣਾਓ।
7. ਮੌਜੂਦਾ ਕੋਡ ਨੂੰ GitLab 'ਤੇ ਪੁਸ਼ ਕਰੋ।
8. ???
9. ਲਾਭ!

ਕਦਮ 1. ਟੋਕਨ ਭਾਗ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ API ਕੁੰਜੀਆਂ.

ਕਦਮ 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. ਸਾਨੂੰ cubeconfig ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ.

ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ KUBECONFIG ਨੂੰ ਡਾਉਨਲੋਡ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਓਪਨਸਟੈਕ ਤੋਂ ਇੱਕ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

openstack token issue -c id -f value > token

ਅਤੇ ਇਸ ਟੋਕਨ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕੁਬਰਨੇਟਸ ਸਿਲੈਕਟਲ API ਨੂੰ ਬੇਨਤੀ ਕਰੋ। k8s_id ਬਾਹਰ ਦਿੰਦਾ ਹੈ ਟਰਾਫਾਰਮ:

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. ਕਲੱਸਟਰ ਦੇ ਬੇਕ ਹੋਣ ਤੋਂ ਬਾਅਦ ਅਤੇ ਸਾਡੇ ਕੋਲ ਇਸ ਤੱਕ ਪਹੁੰਚ ਹੈ, ਅਸੀਂ ਸੁਆਦ ਲਈ ਸਿਖਰ 'ਤੇ ਯਾਮਲ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹਾਂ।

ਮੈਂ ਸ਼ਾਮਲ ਕਰਨਾ ਪਸੰਦ ਕਰਦਾ ਹਾਂ:

• ਨਾਮ ਸਥਾਨ
• ਸਟੋਰੇਜ਼ ਕਲਾਸ
• ਪੌਡ ਸੁਰੱਖਿਆ ਨੀਤੀ ਅਤੇ ਹੋਰ.

ਸਟੋਰੇਜ ਕਲਾਸ ਸਿਲੈਕਟਲ ਤੋਂ ਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਧਿਕਾਰਤ ਰਿਪੋਜ਼ਟਰੀ.

ਕਿਉਂਕਿ ਸ਼ੁਰੂ ਵਿੱਚ ਮੈਂ ਜ਼ੋਨ ਵਿੱਚ ਇੱਕ ਕਲੱਸਟਰ ਚੁਣਿਆ ਸੀ ru-3a, ਫਿਰ ਮੈਨੂੰ ਇਸ ਜ਼ੋਨ ਤੋਂ ਸਟੋਰੇਜ ਕਲਾਸ ਦੀ ਲੋੜ ਹੈ।

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 ਮਿੰਟਾਂ ਲਈ ਇੱਕ ਬਾਹਰੀ IP ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹਾਂ:

ਪ੍ਰਾਪਤ ਕੀਤਾ ਬਾਹਰੀ IP:

ਕਦਮ 6. GitLab ਇੰਸਟਾਲ ਕਰੋ।

$ 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 ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ ਵਿਰੋਧੀ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਹੱਥੀਂ ਮਿਟਾਉਣਾ ਹੋਵੇਗਾ। ਫਿਰ '$make all' ਕਮਾਂਡ ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਓ

ਕਦਮ 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)

ਹੋ ਗਿਆ:

ਸਿੱਟਾ

ਅਸੀਂ ਇਹ ਪ੍ਰਾਪਤ ਕੀਤਾ ਹੈ ਕਿ ਅਸੀਂ ਆਪਣੀ ਸਥਾਨਕ ਮਸ਼ੀਨ ਤੋਂ ਹਰ ਚੀਜ਼ ਨੂੰ ਘੋਸ਼ਣਾਤਮਕ ਤੌਰ 'ਤੇ ਪ੍ਰਬੰਧਿਤ ਕਰ ਸਕਦੇ ਹਾਂ। ਹੁਣ ਮੈਂ ਇਹਨਾਂ ਸਾਰੇ ਕੰਮਾਂ ਨੂੰ CI ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ ਅਤੇ ਸਿਰਫ਼ ਬਟਨ ਦਬਾਓ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਆਪਣੇ ਸਥਾਨਕ ਰਾਜਾਂ (ਟੈਰਾਫਾਰਮ ਸਟੇਟ) ਨੂੰ ਸੀਆਈ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਹੈ.

ਸਾਡੇ ਲਈ ਗਾਹਕ ਬਣੋ ਬਲੌਗਤਾਂ ਜੋ ਨਵੇਂ ਲੇਖਾਂ ਦੀ ਰਿਲੀਜ਼ ਨੂੰ ਖੁੰਝ ਨਾ ਜਾਵੇ!

ਸਰੋਤ: www.habr.com