पैकर, टेराफॉर्म और Ansible: कुबेरनेट्स क्लस्टर की तैनाती एक घंटे में

मुर्गियों को नाम न दें

बेक्ड केक तले हुए की तुलना में स्वास्थ्यवर्धक होते हैं

हम ओवन शुरू करते हैं। लपेटनेवाला

बेस.जसन संरचना

"variables" : {
 "source_ami_name": "{{env SOURCE_AMI_NAME}}",
 "ami_name": "{{env AMI_NAME}}",
 "instance_type": "{{env INSTANCE_TYPE}}",
 "kubernetes_version": "{{env KUBERNETES_VERSION}}",
 "docker_version": "{{env DOCKER_VERSION}}",
 "subnet_id": "",
 "availability_zone": "",
},

"builders" : [
 {
  "type": "amazon-ebs",
  "region": "croc",
  "skip_region_validation": true,
  "custom_endpoint_ec2": "https://api.cloud.croc.ru",
  "source_ami": "",
  "source_ami_filter": {
   "filters": {
    "name": "{{user `source_ami_name`}}"
    "state": "available",
    "virtualization-type": "kvm-virtio"
     },
...

"instance_type": "{{user `instance_type`}}",
"launch_block_device_mappings": [
 {
  "device_name": "disk1",
  "volume_type": "io1",
  "volume_size": "8",
  "iops": "1000",
  "delete_on_termination": "true"
 }
],

"availability_zone": "{{user `availability_zone`}}",
"subnet_id": "{{user `subnet_id`}}",
"associate_public_ip_address": true,
"ssh_username": "ec2-user",
"ami_name": "{{user `ami_name`}}"

"provisioners": [
 {
  "type": "ansible",
  "playbook_file": "playbook.yml",
  "extra_arguments": [
   "--extra-vars",
   "kubernetes_version={{user `kubernetes_version`}}",
   "--extra-vars",
   "docker_version={{user `docker_version`}}"
   ]
  }
]

CROC Cloud की तैयारी

1. हाइलाइट एड्रेस पर क्लिक करें। पैकर अपने आप वांछित सफेद आईपी पता प्राप्त करेगा।
2. सबनेट बनाएं पर क्लिक करें और एक सबनेट और मास्क निर्दिष्ट करें।
3. सबनेट आईडी कॉपी करें।
4. इस मान को पैकर स्टार्टअप कमांड के सबनेट_आईडी पैरामीटर में डालें।

Ansible

- hosts: all
  become: true

  roles:
  | - base

1. सिस्टम टेम्प्लेट में डॉकर रिपॉजिटरी जोड़ता है।
2. सिस्टम टेम्प्लेट में कुबेरनेट्स रिपॉजिटरी जोड़ता है।
3. आवश्यक पैकेज स्थापित करता है।
4. डॉकर डेमन को कॉन्फ़िगर करने के लिए एक निर्देशिका बनाता है।
5. मशीन को डेमन.जॉन.जे 2 विन्यास फाइल के अनुसार कॉन्फ़िगर करता है।
6. Br_netfilter कर्नेल लोड करता है।
7. Br_netfilter के लिए आवश्यक विकल्प शामिल हैं।
8. इसमें डॉकर और क्यूबलेट घटक शामिल हैं।
9. VM में डॉकर चलाता है।
10. कुबेरनेट्स के काम करने के लिए आवश्यक डॉक छवियों को डाउनलोड करने वाली एक कमांड चलाता है।

टेराफॉर्म - कोड के रूप में बुनियादी ढाँचा

हम परियोजना का वर्णन करते हैं

1. main.tf
2. network.tf
3. security_groups.tf
4. master.tf
5. master.tpl

Main.tf फ़ाइल संरचना

provider "aws" {
 endpoints {
  ec2 = "https://api.cloud.croc.ru"
 }

resource "tls_private_key" "ssh" {
 algorithm = "RSA"
}
resource "aws_key_pair" "kube" {
 key_name = "terraform"
 public_key = "${tls_private_key.ssh.public_key_openssh}"
}
output "ssh" {
value = "${tls_private_key.ssh.private_key_pem}"
}

Network.tf फ़ाइल की संरचना

data "aws_availability_zones" "az" {
 state = "available"
}
resource "aws_vpc" "kube" {
 cidr_block = "${var.vpc_cidr}"
}
resource "aws_eip" "master" {
 count = "1"
 vpc = true
}
resource "aws_subnet" "private" {
 vpc_id = "${aws_vpc.kube.id}"
 count = "${length(data.aws_availability_zones.az.names)}"
 cidr_block = "${var.private_subnet_cidr_list[count.index]}"
 availability_zone = "${data.aws_availability_zones.az.names[count.index]}"
}

• संसाधन - क्या बनाने की जरूरत है;
• डेटा - आपको क्या प्राप्त करने की आवश्यकता है।

Security_groups.tf फ़ाइल संरचना

resource "aws_security_group" "kube" {
 vpc_id = "${aws_vpc.kube.id}"
 name   = "kubernetes"
 # Allow all outbound
 egress {
  from_port = 0
  to_port = 0
  protocol = "-1"
  cidr_blocks = ["0.0.0.0/0"]
 }
 # Allow all internal
 ingress {
  from_port = 0
  to_port = 0
  protocol = "-1"
  cidr_blocks = ["${var.vpc_cidr}"]
 }
}
resource "aws_security_group" "ssh" {
 vpc_id = "${aws_vpc.kube.id}"
 name   = "ssh"

 # Allow all inbound
 ingress {
  from_port = 22
  to_port = 22
  protocol = "tcp"
  cidr_blocks = ["0.0.0.0/0"]
 }
}

मास्टर नोड। Master.tf फ़ाइल संरचना

resource "aws_instance" "master" {
 count = "1"
 ami = "${var.kubernetes_ami}"
 instance_type = "c3.large"
 disable_api_termination = false
 instance_initiated_shutdown_behavior = "terminate"
 source_dest_check = false
 subnet_id = "${aws_subnet.private.*.id[count.index % length(data.aws_availability_zones.az.names)]}"
 associate_public_ip_address = true
 vpc_security_group_ids = [
  "${aws_security_group.ssh.id}",
  "${aws_security_group.kube.id}",
 ]
 key_name = "${aws_key_pair.kube.key_name}"
 user_data = "${data.template_cloudinit_config.master.rendered}"
 monitoring = "true"
}

मास्टर नोड। मेघ इनिट

#cloud-config

    write_files:
    - path: etc/kubernetes/kubeadm.conf
      owner: root:root
      content:
    ...

• विज़ार्ड का आईपी पता उत्पन्न कॉन्फ़िगरेशन फ़ाइल को लिखा जाता है;
• कुबेरनेट्स क्लस्टर में मास्टर को कुबेदम इनिट कमांड के साथ आरम्भ किया गया है;
• Kubernetes क्लस्टर में, Calico ओवरले नेटवर्क kubectl लागू कमांड के साथ स्थापित किया गया है।

runcmd:
         - sed -i "s/CONTROL_PLANE_IP/$(curl http://169.254.169.254/latest/meta-data-local-ipv4)/g" /etc/kubernetes/kubeadm.conf
         - kubeadm init --config /etc/kubernetes/kubeadm.conf
         - mkdir -p $HOME/.kube
         - sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
         - sudo chown $(id -u):$(id -g) $HOME/.kube/config
         - kubectl apply -f https://docs.projectcalico.org/v3.8/manifests/calico.yaml

साधारण नोड्स। node.tf

resource "aws_instance" "node" {
 count = "${var.nodes_count}"
 ami = "${var.kubernetes_ami}"
 instance_type = "c3.large"

टेराफॉर्म लॉन्च करें

• AWS मॉड्यूल
• टेम्पलेट मॉड्यूल;
• टीएलएस मॉड्यूल प्रमुख पीढ़ी के लिए जिम्मेदार है।

terraform init terraform/

terraform plan -var-file terraform/vars/dev.tfvars terraform/

• Kubernetes_version (Kubernetes का स्थापित संस्करण);
• Kubernetes_ami (AMI छवि जो पैकर ने बनाई)।

कुबेरनेट्स क्लस्टर संरचना

• ईटीसीडी, यानी कुबेरनेट्स डेटाबेस
• एपीआई सर्वर, जिसके माध्यम से हम कुबेरनेट्स में जानकारी संग्रहीत करते हैं और उससे जानकारी प्राप्त करते हैं;
• नियंत्रक प्रबंधक
• समयबद्धक

• क्यूब-प्रॉक्सी (कुबेरनेट क्लस्टर में नेटवर्क नियम बनाने के लिए जिम्मेदार);
• क्यूबलेट (कुबेरनेट्स क्लस्टर में एप्लिकेशन चलाने के लिए डॉकर डेमन को कमांड भेजने के लिए जिम्मेदार)।

क्लस्टर वर्कफ़्लो आरेख

, Kubernetes replicaset.

1. API-, ETCD. .
2. API- .
3. Controller-manager API- , «», .
4. Scheduler . ETCD API-.
5. Kubelet API- Docker .
6. Docker .
7. Kubelet API- , .

, Kubernetes , . , , YAML-. , , API-. .

Kubeadm

• सभी प्रमुख क्लस्टर घटकों को स्थापित, कॉन्फ़िगर और चलाएं
• प्रमाणपत्रों को प्रबंधित करें, जिनमें उन्हें घुमाना और नए लिखना शामिल है;
• क्लस्टर घटक संस्करणों (अपग्रेड और डाउनग्रेड) का प्रबंधन करें।

सभी फाइलों के साथ रिपोजिटरी