Ich muss den Kubernetes-Cluster erhöhen, bin aber nur ein Code-Programmierer. Es gibt einen Ausweg

Guten Tag. Noch ein Hinweis aus meiner Erfahrung. Diesmal geht es oberflächlich um die Basisinfrastruktur , die ich verwende, wenn ich etwas entladen muss, aber es sind keine Entwickler in der Nähe . Der derzeitige Abstraktionsgrad in der Technologie ermöglicht es jedoch, etwa ein Jahr lang mit dieser Infrastruktur zu leben, die während der Nacht mithilfe des Internets und vorgefertigter Dinge aufgebaut wurde.

Schlüsselwörter - AWS + Terraform + Kops . Wenn dies für mich nützlich ist, wird es wahrscheinlich für jemand anderen nützlich sein. Willkommen zu den Kommentaren.

-1. Womit wir es zu tun haben

Die klassische Situation - das Projekt wird in eine solche Phase geschrieben, in der es irgendwo entladen und verwendet werden muss. Und das Projekt ist komplizierter als eine einfache HTML-Seite. Ich möchte die Möglichkeit einer horizontalen Skalierung, die Identität der Umgebung auf lokalen, Test-, Produktständen und einen mehr oder weniger normalen Bereitstellungsprozess.

Es geht um eine Anwendung auf Laravel , die den gesamten Prozess von Anfang bis Ende zeigt. Auf ähnliche Weise können Sie jedoch eine Reihe von Diensten für unterwegs, Python-Anwendungen, kleine Websites in WP, HTML-Seiten und vieles mehr bereitstellen. Bis zu einem gewissen Grad reicht dies aus, und dann erscheint eine separate Person im Team, die es verbessern und ergänzen wird.

Kürzlich kam ich zu der Tatsache, dass ich GoLand, PhpStorm, Docker, Git auf lokalen Computern installiere und bereit bin zu arbeiten. Ja, und Sie können von einem einzigen Computer aus in Massenclustern verwalten. Daher werde ich den gesamten Prozess beschreiben, ohne das Betriebssystem zu berücksichtigen, auf dem Sie arbeiten, und alle Dinge in einen Docker-Container packen.

0. Vorbereitungen für die Arbeit.

Stellen wir uns vor, wir haben bereits ein Konto bei AWS registriert, vom technischen Support gebeten, die Kontolimits um die Anzahl der gleichzeitig ausgeführten Server zu erhöhen, einen IAM- Benutzer erstellt und jetzt haben wir Zugriffsschlüssel + Geheimschlüssel . Zone - us-east-1 .

Was brauchen wir auf dem lokalen Computer? AWS CLI , Terraform für die deklarative Verwaltung von AWS , kubectl , kops für die Konfiguration des Clusters und Helm für die Bereitstellung einiger Dienste. Wir sammeln die Docker-Datei (die ich vor langer Zeit irgendwo in der Weite des Githubs gefunden habe, aber ich kann nicht finden, wo). Wir schreiben unsere docker-compose.yml für Mount-Verzeichnisse und Makefile für Aliase.


Dockerfile - Nehmen Sie das grundlegende Ubuntu-Image und installieren Sie die gesamte Software. Makefile - nur zur Vereinfachung können Sie den üblichen Aliase-Mechanismus verwenden. Docker-compose.yml - Wir haben einen zusätzlichen Container hinzugefügt , der uns in den K8S Dashboard- Browser wirft , wenn Sie etwas visuell sehen müssen.

Wir erstellen die Ordner data , .ssh , .kube , .aws im Stammverzeichnis und legen dort unsere Konfiguration für aws, ssh-Schlüssel ab. Wir können unseren Container über make docker.build & make docker.run sammeln und ausführen .

Nun, erstellen Sie im Datenordner einen Ordner, in dem wir yaml k8s- Dateien ablegen , und neben dem zweiten, in dem wir den Status der Terraform des Clusters speichern. Ich habe das ungefähre Ergebnis dieser Etappe auf den Github gelegt .

1. Erhöhen Sie unseren Cluster.

Als nächstes folgt eine kostenlose Übersetzung dieser Notiz. Ich werde viele theoretische Punkte weglassen und versuchen, einen kurzen Druck zu beschreiben. Trotzdem ist das Format meiner Notiz tldr.

In unserem Ordner data / aws-cluster-init-kops-terraform klonen wir, was sich in diesem Repository befindet, und gehen über make docker.bash zur Containerkonsole. Die Streuung langweiliger Teams beginnt.

AWS CLI

Wir erstellen die User- Kops , fügen Zugriffsrechte hinzu und konfigurieren die AWS-CLI neu , um keine Befehle vom Superuser auszuführen.

 aws iam create-group --group-name kops #   aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2FullAccess --group-name kops aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonRoute53FullAccess --group-name kops aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess --group-name kops aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/IAMFullAccess --group-name kops aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AWSCertificateManagerFullAccess --group-name kops aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonVPCFullAccess --group-name kops aws iam create-user --user-name kops aws iam add-user-to-group --user-name kops --group-name kops aws iam create-access-key --user-name kops 

 aws configure 

Terraform initialisieren

Ändern Sie in der Datei data / aws-cluster-init-kops-terraform / variables.tf den Namen des Clusters in den gewünschten. Vergessen Sie nicht, unsere DNS-Server aus der Datei update.json zu entnehmen und dort zu aktualisieren, wo Sie Ihre Domain gekauft haben.

 #    cd /data/aws-cluster-init-kops-terraform #    AWS CLI export AWS_ACCESS_KEY_ID=$(aws configure get aws_access_key_id) export AWS_SECRET_ACCESS_KEY=$(aws configure get aws_secret_access_key) #  terraform terraform init terraform get terraform apply #  NS  cat update-zone.json \ | jq ".Changes[].ResourceRecordSet.Name=\"$(terraform output name).\"" \ | jq ".Changes[].ResourceRecordSet.ResourceRecords=$(terraform output -json name_servers | jq '.value|[{"Value": .[]}]')" \ > update-zone.json 

Kops

Wir erstellen einen Cluster durch Kops und exportieren die Konfiguration in eine .tf- Datei.

 export NAME=$(terraform output cluster_name) export KOPS_STATE_STORE=$(terraform output state_store) export ZONES=$(terraform output -json availability_zones | jq -r '.value|join(",")') kops create cluster \ --master-zones $ZONES \ --zones $ZONES \ --topology private \ --dns-zone $(terraform output public_zone_id) \ --networking calico \ --vpc $(terraform output vpc_id) \ --target=terraform \ --out=. \ ${NAME} 

Hier ist eine kleine Bemerkung erforderlich. Terraform erstellt eine VPC , und wir müssen die Konfiguration, die Kops uns geben , leicht anpassen . Dies geschieht ganz einfach über das Hilfbild von Ryane / Gensubnets: 0.1

 #   terraform output -json > subnets.json 

 #     echo subnets.json | docker run --rm -i ryane/gensubnets:0.1 

Sie können sofortige Richtlinien für route53 hinzufügen.

 additionalPolicies: master: | [ { "Effect": "Allow", "Action": ["route53:ListHostedZonesByName"], "Resource": ["*"] }, { "Effect": "Allow", "Action": ["elasticloadbalancing:DescribeLoadBalancers"], "Resource": ["*"] }, { "Effect": "Allow", "Action": ["route53:ChangeResourceRecordSets"], "Resource": ["*"] } ] node: | [ { "Effect": "Allow", "Action": ["route53:ListHostedZonesByName"], "Resource": ["*"] }, { "Effect": "Allow", "Action": ["elasticloadbalancing:DescribeLoadBalancers"], "Resource": ["*"] }, { "Effect": "Allow", "Action": ["route53:ChangeResourceRecordSets"], "Resource": ["*"] } ] 

Bearbeiten über Kops Bearbeiten Sie Cluster $ {NAME} .



Jetzt können wir den Cluster selbst anheben.

 kops update cluster \ --out=. \ --target=terraform \ ${NAME} terraform apply 

Alles wird gut gehen, der Kontext von kubectl wird sich ändern. Im Ordner data / aws-cluster-init-kops-terraform speichern wir den Clusterstatus. Sie können einfach alles in git einfügen und an ein privates Bitpack-Repository senden.

 $ kubectl get nodes NAME STATUS AGE ip-10-20-101-252.ec2.internal Ready,master 7m ip-10-20-103-232.ec2.internal Ready,master 7m ip-10-20-103-75.ec2.internal Ready 5m ip-10-20-104-127.ec2.internal Ready,master 6m ip-10-20-104-6.ec2.internal Ready 5m 

2. Erhöhen Sie unsere Anwendung

Nachdem wir etwas haben, können wir unsere Dienste in einem Cluster bereitstellen. Ich werde ungefähre Konfigurationen in dasselbe Repository stellen . Sie können in data / k8s in ein Paket gestellt werden .

Service-Witze

Beginnen wir mit dem Service. Wir benötigen Helm , Route53 , Speicherklassen und Zugriff auf unsere private Registrierung unter hub.docker.com . Nun, oder zu jedem anderen, wenn es einen solchen Wunsch gibt.

 # Init helm kubectl create serviceaccount --namespace kube-system tiller kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller kubectl patch deploy --namespace kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}' helm init 

 kubectl apply -f default-namespace.yaml kubectl apply -f storage-classes.yaml kubectl apply -f route53.yaml kubectl apply -f docker-hub-secret.yml kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/master/src/deploy/recommended/kubernetes-dashboard.yaml 

PostgreSQL + Redis

Ich habe so oft mit Docker gebrannt, nicht für zustandslose Container, aber die letzte Konfiguration hat sich bisher als am besten geeignet erwiesen. Ich benutze Stolon , um Skalierbarkeit zu gewährleisten. Etwa ein Jahr ist der Flug normal.

Wir setzen Helmkarten und ein paar schnelle Redis- Konfigurationen ein.

 #  etcd  stolon cd etcd-chart helm install --name global-etcd . #   stolon cd stolon-chart helm dep build helm install --name global-postgres . #  redis kubectl apply -f redis 

Nginx + php

Der übliche Haufen. Nginx und PHP-Fpm . Ich habe die Konfigurationen nicht besonders bereinigt, aber jeder kann sie selbst konfigurieren. Bevor Sie sich bewerben, müssen Sie das Bild angeben, von dem wir den Code übernehmen möchten, und eine Zertifikatzeile von AWS Certificate Manager hinzufügen. PHP selbst - Sie können es aus dem Dockerhab nehmen, aber ich habe mein privates erstellt, indem ich ein paar Bibliotheken hinzugefügt habe.

 kubectl apply -f nginx kubectl apply -f php 

In unserem Bild mit dem Code speichern wir ihn im Ordner / crm-code . Wir ersetzen es durch Ihr Bild und es wird ganz richtig funktionieren. Die Datei lautet nginx / deploy.yml .



Bringen Sie die Domain heraus. Der Route53- Dienst nimmt es auf, ändert / fügt DNS-Einträge hinzu, und das Zertifikat wird vom AWS Certificate Manager in ELB hochgeladen . Die Datei lautet nginx / service.yml .



Leiten Sie env-Variablen in PHP weiter, um sie darin zu haben und eine Verbindung zu PostgreSQL / Redis herzustellen . Die Datei ist php / deploy.yml .



Als Ergebnis haben wir einen K8S- Cluster, den wir auf einer grundlegenden Ebene skalieren, neue Dienste, neue Server (Knoten) hinzufügen, die Anzahl der PostgreSQL-, PHP- und Nginx- Instanzen ändern und leben können, bevor eine separate Person im Team erscheint, die dies tun wird .

Als Teil dieser kurzen Notiz werde ich nicht auf Sicherungs- / Überwachungsprobleme all dieser Dinge eingehen. In der Anfangsphase reicht localhost aus : 8001 / ui vom K8S Dashboard- Dienst. Später können Prometheus , Grafana , Barman oder ähnliche Lösungen befestigt werden.

Wenn Jenkins ein Terminal oder Teamcity verwendet , aktualisiert er den Code in etwa so.

 #     -      Teamcity docker build -t GROUP/crm-code:latest . docker push GROUP/crm-code:latest #   (  ) kubectl set image deployment/php-fpm php-fpm=GROUP/php-fpm kubectl rollout status deployment/php-fpm kubectl set image deployment/php-fpm php-fpm=GROUP/php-fpm:latest kubectl set image deployment/nginx nginx=danday74/nginx-lua kubectl rollout status deployment/nginx kubectl set image deployment/nginx nginx=danday74/nginx-lua:latest kubectl rollout status deployment/php-fpm kubectl rollout status deployment/nginx 

Ich würde mich freuen, wenn es für jemanden interessant wäre und doppelt froh, wenn es jemandem hilft. Vielen Dank für Ihre Aufmerksamkeit. Ich füge noch einmal einen Link zum Repository eins und zwei hinzu .