ProHoster > blog > amministrazione > L'uovo o la gallina: scissione dell'IaC

L'uovo o la gallina: scissione dell'IaC

L'uovo o la gallina: scissione dell'IaC
E 'nato prima l'uovo o la gallina? Un inizio piuttosto strano per un articolo su Infrastructure-as-Code, non è vero?

Cos'è un uovo?

Molto spesso, Infrastructure-as-Code (IaC) è un modo dichiarativo di rappresentare l'infrastruttura. In esso descriviamo lo stato che vogliamo raggiungere, partendo dalla parte hardware e finendo con la configurazione software. Pertanto IaC viene utilizzato per:

  1. Fornitura di risorse. Queste sono VM, S3, VPC, ecc. Strumenti di base per il lavoro: Terraform и CloudFormazione.
  2. Configurazione software. Strumenti di base: ansible, cuoco, ecc.

Qualsiasi codice è nei repository git. E prima o poi il caposquadra deciderà che devono essere messi in ordine. E farà il refactoring. E creerà una certa struttura. E vedrà che questo va bene.

È anche positivo che esista già GitLab и GitHub-provider per Terraform (e questa è Configurazione software). Con il loro aiuto, puoi gestire l'intero progetto: membri del team, CI/CD, git-flow, ecc.

Da dove viene l'uovo?

Quindi ci stiamo avvicinando gradualmente alla domanda principale.

Prima di tutto, devi iniziare con un repository che descriva la struttura di altri repository, incluso te stesso. E ovviamente, come parte di GitOps, è necessario aggiungere CI in modo che le modifiche vengano eseguite automaticamente.

Se Git non è stato ancora creato?

  1. Come memorizzarlo in Git?
  2. Come installare CI?
  3. Se distribuissimo Gitlab anche utilizzando IaC e anche in Kubernetes?
  4. E GitLab Runner anche in Kubernetes?
  5. Che dire di Kubernetes nel cloud provider?

Cos'è venuto prima: il GitLab in cui caricherò il mio codice o il codice che descrive di che tipo di GitLab ho bisogno?

Pollo con uova

«Oyakodon3 con un dinosauro" [src]

Proviamo a cucinare un piatto utilizzando come fornitore di servizi cloud Selezione Kubernetes gestita.

TL; DR

È possibile unirsi a una squadra contemporaneamente?

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

Ingredienti:

  • Conto da my.selectel.ru;
  • Gettone del conto;
  • Competenze Kubernetes;
  • Abilità del timone;
  • Abilità di terraformazione;
  • Grafico timone GitLab;
  • Grafico timone GitLab Runner.

ricetta:

  1. Ottieni MY_SELECTEL_TOKEN dal pannello my.selectel.ru.
  2. Crea un cluster Kubernetes trasferendovi un token di account.
  3. Ottieni KUBECONFIG dal cluster creato.
  4. Installa GitLab su Kubernetes.
  5. Ottieni il token GitLab da GitLab creato per l'utente radice.
  6. Crea una struttura di progetto in GitLab utilizzando il token GitLab.
  7. Invia il codice esistente a GitLab.
  8. ?
  9. Utile!

Passo 1. Il token può essere ottenuto nella sezione Chiavi API.

L'uovo o la gallina: scissione dell'IaCPasso 2. Prepariamo il nostro Terraform per “cuocere” un cluster di 2 nodi. Se sei sicuro di avere risorse sufficienti per tutto, puoi abilitare le quote automatiche:

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",
 }
}

Aggiungi un utente al progetto:

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
}

Dati di uscita:

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
}

eseguire:

$ 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

L'uovo o la gallina: scissione dell'IaC
Passo 3. Otteniamo il file cubeconfig.

Per scaricare KUBECONFIG a livello di programmazione, devi ottenere un token da OpenStack:

openstack token issue -c id -f value > token

E con questo token effettua una richiesta all'API Managed Kubernetes Selectel. k8s_id problemi Terraform:

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

È possibile accedere a Cupconfig anche tramite il pannello.

L'uovo o la gallina: scissione dell'IaC
Passo 4. Dopo che il grappolo è cotto e abbiamo accesso ad esso, possiamo aggiungere yaml sopra a piacere.

Preferisco aggiungere:

  • spazio dei nomi,
  • classe di archiviazione
  • politica di sicurezza del pod e così via.

Classe di stoccaggio per Selectel può essere preso da deposito ufficiale.

Inizialmente ho selezionato un cluster nella zona ru-3a, allora ho bisogno della classe di archiviazione di questa zona.

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

Passo 5. Installa un bilanciatore del carico.

Per molti useremo quello standard nginx-ingresso. Ci sono già molte istruzioni per installarlo, quindi non ci soffermeremo su questo.

$ 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

Aspettiamo che riceva un IP esterno per circa 3-4 minuti:

L'uovo o la gallina: scissione dell'IaC
IP esterno ricevuto:

L'uovo o la gallina: scissione dell'IaC
Passo 6. Installa 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"

Ancora una volta aspettiamo che tutti i baccelli si alzino.

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

I baccelli si alzarono:

L'uovo o la gallina: scissione dell'IaC
Passo 7. Riceviamo il token GitLab.

Per prima cosa, scopri la password di accesso:

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

Ora accediamo e otteniamo un token:

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

Passo 8. Portare i repository Git alla gerarchia corretta utilizzando Gitlab Provider.

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

Sfortunatamente, il provider terraform GitLab ha un file float insetto. Quindi dovrai eliminare manualmente i progetti in conflitto per poter correggere tf.state. Quindi esegui nuovamente il comando "$make all".

Passo 9. Trasferiamo i repository locali sul server.

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

Finitura:

L'uovo o la gallina: scissione dell'IaC
L'uovo o la gallina: scissione dell'IaC
L'uovo o la gallina: scissione dell'IaC

conclusione

Abbiamo ottenuto che possiamo gestire tutto in modo dichiarativo dalla nostra macchina locale. Ora voglio trasferire tutte queste attività su CI e basta premere i pulsanti. Per fare ciò, dobbiamo trasferire i nostri stati locali (stato Terraform) a CI. Come farlo è nella parte successiva.

Iscriviti al nostro blogper non perdere l'uscita di nuovi articoli!

Fonte: habr.com

Aggiungi un commento