Ech proposéieren Iech den Transkript vum Bericht vum Alexander Sigachev vun Inventos "Entwécklung an Testprozess mat Docker + Gitlab CI" ze liesen
Déi, déi just ufänken den Entwécklungs- an Testprozess ëmzesetzen baséiert op Docker + Gitlab CI stellen dacks Basisfroen. Wou ufänken? Wéi organiséieren? Wéi testen?
Dëse Bericht ass gutt well et op eng strukturéiert Manéier iwwer den Entwécklungs- an Testprozess mat Docker a Gitlab CI schwätzt. De Rapport selwer ass vun 2017. Ech denken datt Dir aus dësem Bericht d'Grondlage, d'Methodologie, d'Iddi an d'Erfahrung vun der Benotzung kënnt sammelen.
Wien egal, w.e.g. ënnert der Kaz.
Mäin Numm ass Alexander Sigachev. Ech schaffen fir Inventos. Ech soen Iech iwwer meng Erfahrung mat Docker a wéi mir et graduell op Projeten an der Firma implementéieren.
Thema vum Bericht: Entwécklungsprozess mat Docker a Gitlab CI.
Dëst ass meng zweet Diskussioun iwwer Docker. Zu der Zäit vum éischte Bericht hu mir Docker nëmmen an der Entwécklung op Entwécklermaschinnen benotzt. D'Zuel vun de Mataarbechter, déi Docker benotzt hunn, war ongeféier 2-3 Leit. Lues a lues gouf Erfahrung gesammelt a mir sinn e bësse méi wäit gaang. Link op eis .
Wat wäert an dësem Bericht sinn? Mir deelen eis Erfahrung iwwer wéi eng Raken mir gesammelt hunn, wéi eng Probleemer mir geléist hunn. Et war net iwwerall schéin, mee et erlaabt eis weider ze plënneren.
Eist Motto: alles wat mir an d’Hänn kréien, dockeriséieren.
Wéi eng Problemer léise mir?
Wann eng Firma e puer Teams huet, ass de Programméierer eng gemeinsam Ressource. Et gi Stadien wann e Programméierer aus engem Projet erausgezunn ass an en anere Projet fir eng Zäit gëtt.
Fir e Programméierer séier ze verstoen, muss hien de Quellcode vum Projet eroflueden an en Ëmfeld esou séier wéi méiglech lancéieren, wat him erlaabt weider an der Léisung vun de Probleemer vun dësem Projet weiderzekommen.
Normalerweis, wann Dir vun Null ufänkt, gëtt et wéineg Dokumentatioun am Projet. Nëmmen Oldtimer hunn Informatiounen iwwer wéi een se opstellt. D'Employéen hunn an engem oder zwee Deeg hir Aarbechtsplaz eleng opgeriicht. Fir dëst ze beschleunegen, hu mir Docker benotzt.
Den nächste Grond ass d'Standardiséierung vun Astellungen an der Entwécklung. A menger Erfahrung huelen d'Entwéckler ëmmer d'Initiativ. An all fënneften Fall gëtt e personaliséierten Domain aginn, zum Beispill vasya.dev. Niewt mir sëtzt mäi Noper Petya, deem säin Domain petya.dev ass. Si entwéckelen eng Websäit oder e Systemkomponent mat dësem Domain Numm.
Wann de System wiisst an dës Domain Nimm fänken un an der Konfiguratioun abegraff ze ginn, entsteet e Konflikt an Entwécklungsëmfeld an de Site Wee gëtt nei geschriwwe.
Datselwecht geschitt mat Datebank Astellungen. E puer Leit stéieren net mat Sécherheet a schaffen mat engem eidele Root Passwuert. Op der Installatiounsstadium huet MySQL een no engem Passwuert gefrot an d'Passwuert huet sech erausgestallt 123. Et geschitt dacks datt d'Datebankkonfiguratioun stänneg geännert huet ofhängeg vum Engagement vum Entwéckler. Een huet korrigéiert, een huet d'Konfiguratioun net korrigéiert. Et waren Tricken wa mir e puer Testkonfiguratioun setzen .gitignore an all Entwéckler huet d'Datebank installéiert. Dëst huet de Startprozess méi schwéier gemaach. Ënner anerem musst Dir iwwer d'Datebank erënneren. D'Datebank muss initialiséiert ginn, e Passwuert muss registréiert ginn, e Benotzer muss registréiert sinn, e Schëld muss erstallt ginn, a sou weider.
En anere Problem ass verschidde Versioune vu Bibliothéiken. Et geschitt dacks datt en Entwéckler op verschiddene Projete schafft. Et gëtt e Legacy-Projet, dee viru fënnef Joer ugefaang huet (vun 2017 - Redaktiounsnotiz). Am Ufank hu mir ugefaang mat MySQL 5.5. Et ginn och modern Projete wou mir probéieren méi modern Versioune vu MySQL ëmzesetzen, zum Beispill 5.7 oder méi al (am 2017 - Redaktiounsnotiz)
Jiddereen dee mat MySQL schafft weess datt dës Bibliothéiken Ofhängegkeeten droen. Et ass zimlech problematesch 2 Datenbanken zesummen ze lafen. Op d'mannst ass et problematesch al Clienten un déi nei Datebank ze verbannen. Dat entsteet dann nees verschidde Problemer.
Den nächste Problem ass wann en Entwéckler op enger lokaler Maschinn schafft, hie benotzt lokal Ressourcen, lokal Dateien, lokal RAM. All Interaktioun zur Zäit vun der Entwécklung vun enger Léisung fir Probleemer gëtt am Kader vun der Tatsaach duerchgefouert datt et op enger Maschinn funktionnéiert. E Beispill wier wann mir Backend-Server an der Produktioun 3 hunn, an den Entwéckler späichert Dateien an de Root-Verzeichnis a vun do hëlt nginx d'Dateien fir op d'Ufro ze reagéieren. Wann esou Code an d'Produktioun kënnt, stellt sech eraus datt de Fichier op engem vun 3 Serveren ass.
D'Richtung vu Mikroservicer entwéckelt sech momentan. Wa mir eis grouss Uwendungen an e puer kleng Komponenten opdeelen, déi matenee interagéieren. Dëst erlaabt Iech Technologien fir eng spezifesch Aufgab Stack ze wielen. Dëst erlaabt Iech och d'Aarbecht an d'Verantwortungsberäich tëscht Entwéckler ze trennen.
E Frontend Entwéckler, entwéckelt am JS, huet praktesch keen Afloss op de Backend. De Backend Entwéckler, am Tour, entwéckelt, an eisem Fall, Ruby on Rails a stéiert net mat Frondend. Interaktioun gëtt mat der API duerchgefouert.
Als Bonus, mat Docker, konnte mir Ressourcen op Staging recycléieren. All Projet, wéinst senge Spezifizitéiten, erfuerdert gewësse Astellungen. Kierperlech war et néideg entweder e virtuelle Server ze verdeelen an se separat ze konfiguréieren, oder eng Aart vu verännerlechen Ëmfeld opzedeelen a Projete kënnen géigesäiteg beaflossen, jee no der Versioun vun de Bibliothéiken.
Tools. Wat benotze mir?
- Docker selwer. Eng Dockerfile beschreift d'Ofhängegkeete vun enger eenzeger Applikatioun.
- Docker-compose ass e Bündel deen e puer vun eisen Docker Uwendungen zesumme bréngt.
- Mir benotzen GitLab fir Quellcode ze späicheren.
- Mir benotzen GitLab-CI fir Systemintegratioun.
De Bericht besteet aus zwee Deeler.
Den éischten Deel wäert Iech soen wéi Dir Docker op d'Maschinnen vun den Entwéckler lafen.
Den zweeten Deel wäert schwätzen iwwer wéi Dir mat GitLab interagéiert, wéi mir Tester lafen a wéi mir op Staging ausrollen.
Docker ass eng Technologie déi et erlaabt (mat enger deklarativer Approche) déi néideg Komponenten ze beschreiwen. Dëst ass e Beispill Dockerfile. Hei erkläre mir datt mir vum offiziellen Docker Bild vum Ruby ierwen: 2.3.0. Et enthält Ruby Versioun 2.3 installéiert. Mir installéieren déi néideg Assemblée Bibliothéiken an NodeJS. Mir beschreiwen datt mir e Verzeechnes erstellen /app. Mir ginn den App-Verzeichnis als Aarbechtsverzeechnes zou. An dësem Verzeechnes setzen mir déi néideg Minimum Gemfile an Gemfile.lock. Da bauen mir Projeten déi dëst Ofhängegkeetsbild installéieren. Mir weisen datt de Container prett ass fir op externen Hafen ze lauschteren 3000. De leschte Kommando ass de Kommando deen eis Applikatioun direkt lancéiert. Wa mir de Projet Run Kommando ausféieren, probéiert d'Applikatioun de spezifizéierte Kommando ze lafen an auszeféieren.
Dëst ass e minimalt Beispill vun enger Docker-Compose Datei. An dësem Fall weisen mir datt et eng Verbindung tëscht zwee Container ass. Dëst ass direkt an den Datebankservice a Webservice. Eis Webapplikatiounen erfuerderen an de meeschte Fäll eng Aart Datebank als Backend fir Daten ze späicheren. Well mir MySQL benotzen, ass d'Beispill mat MySQL - awer näischt verhënnert datt mir eng aner Datebank benotzen (PostgreSQL, Redis).
Mir huelen d'MySQL 5.7.14 Bild ouni Ännerungen vun der offizieller Quell vum Docker Hub. Mir sammelen d'Bild dat verantwortlech ass fir eis Webapplikatioun aus dem aktuellen Verzeechnes. Beim éischte Start sammelt hien e Bild fir eis. Da leeft de Kommando deen mir hei ausféieren. Wa mir zréck goen, wäerte mir gesinn datt de Startbefehl duerch Puma definéiert gouf. Puma ass e Service geschriwwen am Ruby. Am zweete Fall iwwerschreiwe mir. Dëse Kommando kann arbiträr sinn ofhängeg vun eise Besoinen oder Aufgaben.
Mir beschreiwen och datt mir den Hafen op eiser Entwéckler Hostmaschinn vun 3000 op 3000 Containerport weiderginn. Dëst gëtt automatesch mat iptables a säin eegene Mechanismus gemaach, deen direkt an Docker agebonne gëtt.
Den Entwéckler kann, wéi virdrun, Zougang zu all verfügbare IP Adress, zum Beispill 127.0.0.1 lokal oder extern IP Adress vun der Maschinn.
Déi lescht Zeil seet datt de Webcontainer vum db Container hänkt. Wa mir de Webcontainer ruffen fir ze starten, lancéiert docker-compose fir d'éischt d'Datebank fir eis. Schonn um Start vun der Datebank (tatsächlech nom Start vum Container! Dëst garantéiert net d'Bereetschaft vun der Datebank) lancéiert eis Applikatioun, eise Backend.
Dëst erlaabt eis Feeler ze vermeiden wann d'Datebank net op ass an erlaabt eis Ressourcen ze spueren wa mir den Datebankcontainer stoppen, doduerch Ressourcen fir aner Projeten befreien.
Wat gëtt eis mat der Datebank Dockeriséierung op engem Projet? Mir notéieren d'MySQL Versioun fir all Entwéckler. Dëst erlaabt Iech e puer Feeler ze vermeiden déi optrieden wann Versiounen divergéieren, wann d'Syntax, d'Konfiguratioun an d'Standardastellungen änneren. Dëst erlaabt Iech e gemeinsame Hostnumm fir d'Datebank, Login, Passwuert ze spezifizéieren. Mir plënneren ewech vum Zoo vun Nimm a Konflikter a Configuratiounsdateien déi virdru existéiert hunn.
Mir hunn d'Méiglechkeet eng méi optimal Konfiguratioun fir d'Entwécklungsëmfeld ze benotzen, déi sech vum Standard ënnerscheeden. MySQL ass als Standard fir schwaach Maschinnen konfiguréiert a seng Leeschtung aus der Këscht ass ganz niddereg.
Docker erlaabt Iech de Python, Ruby, NodeJS, PHP Dolmetscher vun der gewënschter Versioun ze benotzen. Mir läschen de Besoin fir eng Zort Versiounsmanager ze benotzen. Virdrun gouf e Rpm Package fir Ruby benotzt, wat Iech erlaabt d'Versioun ofhängeg vum Projet z'änneren. Dank dem Docker Container erlaabt dëst Iech och de Code glat ze migréieren a Versioun et zesumme mat Ofhängegkeeten. Mir hu kee Problem d'Versioun vum Dolmetscher an dem Code ze verstoen. Fir d'Versioun ze aktualiséieren, musst Dir den alen Container erofsetzen an den neie Container erhéijen. Wann eppes falsch geet, kënne mir den neie Container erofsetzen, den alen Container erhéijen.
Nodeems Dir d'Bild gebaut huet, sinn d'Container an der Entwécklung a Produktioun d'selwecht. Dëst ass virun allem wouer fir grouss Installatiounen.
Um Frontend benotze mir JavaScipt an NodeJS.
Elo hu mir eise leschte Projet op ReacJS. Den Entwéckler huet alles am Container lancéiert an entwéckelt mat Hot-Reload.
Als nächst gëtt d'Aufgab fir JavaScipt ze montéieren gestart an de statesch gesammelt Code gëtt iwwer nginx geschéckt, Ressourcen spueren.
Hei hunn ech en Diagramm vun eisem leschte Projet geliwwert.
Wéi eng Problemer hues du geléist? Mir haten e Besoin fir e System ze bauen mat deem mobilen Apparater interagéieren. Si kréien Daten. Eng vun de Méiglechkeeten ass Push Notifikatiounen op dësen Apparat ze schécken.
Wat hu mir dofir gemaach?
Mir hunn d'Applikatioun an déi folgend Komponenten opgedeelt: en Admin-Deel am JS, e Backend deen duerch e REST Interface ënner Ruby on Rails funktionnéiert. Backend interagéiert mat der Datebank. D'Resultat dat generéiert gëtt gëtt dem Client kritt. Den Admin Panel interagéiert mam Backend an der Datebank iwwer e REST Interface.
Mir haten och e Besoin fir Push Notifikatiounen ze schécken. Virdru hate mir e Projet an deem e Mechanismus ëmgesat gouf, dee verantwortlech war fir Notifikatiounen op mobil Plattformen ze liwweren.
Mir hunn de folgende Schema entwéckelt: de Bedreiwer vum Browser interagéiert mat der Admin Panel, den Admin Panel interagéiert mam Backend, d'Aufgab ass Push Notifikatiounen ze schécken.
Push Notifikatiounen interagéieren mat engem anere Komponent deen am NodeJS implementéiert ass.
Schlaangen ginn gebaut an Notifikatioune ginn no hirem eegene Mechanismus geschéckt.
Hei sinn zwou Datenbanken gezeechent. Am Moment, mat Docker, benotze mir 2 onofhängeg Datenbanken déi op kee Fall matenee verbonne sinn. Zousätzlech zu der Tatsaach, datt se e gemeinsame virtuellen Netzwierk hunn, a kierperlech Donnéeën sinn a verschiddene Verzeichnisser op der Maschinn vum Entwéckler gespäichert.
Déi selwecht Saach awer an Zuelen. Code Wiederverwendung ass hei wichteg.
Wa mir virdru geschwat hunn iwwer d'Wiederverwendung vu Code a Form vu Bibliothéiken, dann gëtt an dësem Beispill eise Service, deen op Push Notifikatiounen reagéiert, als komplette Server benotzt. Et bitt eng API. An eis nei Entwécklung interagéiert domat.
Zu där Zäit hu mir d'Versioun 4 vun NodeJS benotzt. Elo (am 2017 - Redaktiounsnotiz) an eiser leschter Entwécklung benotze mir d'Versioun 7 vun NodeJS. Et gëtt kee Problem an neie Komponenten fir nei Versioune vu Bibliothéiken ze involvéieren.
Wann néideg, kënnt Dir d'NodeJS Versioun vum Push Notifikatiounsservice refactoréieren an erhéijen.
A wa mir d'API Kompatibilitéit erhalen kënnen, da wäert et méiglech sinn et mat anere Projeten ze ersetzen déi virdru benotzt goufen.
Wat braucht Dir fir Docker ze addéieren? Mir addéieren en Dockerfile an eise Repository, deen déi néideg Ofhängegkeeten beschreift. An dësem Beispill sinn d'Komponente logesch opgedeelt. Dëst ass de Minimum Kit fir e Backend Entwéckler.
Wann Dir en neie Projet erstellt, kreéiere mir eng Dockerfile a beschreiwen den erfuerderlechen Ökosystem (Python, Ruby, NodeJS). Am Docker-compose beschreift et déi néideg Ofhängegkeet - d'Datebank. Mir beschreiwen datt mir eng Datebank vun esou an esou enger Versioun brauchen, fir do an do Daten ze späicheren.
Mir benotzen en separaten drëtten Container mat nginx fir statesch Inhalt ze déngen. Et ass méiglech Biller eropzelueden. De Backend setzt se an e virbereet Volumen, deen och an engem Container mat nginx montéiert ass, wat statesch Donnéeën ubitt.
Fir d'nginx- a mysql-Konfiguratioun ze späicheren, hu mir en Docker-Ordner bäigefüügt, an deem mir déi néideg Konfiguratioune späicheren. Wann en Entwéckler e Git Klon vun engem Repository op senger Maschinn mécht, huet hien schonn e Projet prett fir lokal Entwécklung. Et gëtt keng Fro iwwer wéi en Hafen oder wéi eng Astellunge gëllen.
Als nächst hu mir verschidde Komponenten: Admin, Info-API, Push Notifikatiounen.
Fir dëst alles ze lancéieren, hu mir en anert Repository mam Numm dockerized-App erstallt. Mir benotzen de Moment verschidde Repositories fir all Komponent. Si sinn einfach logesch anescht - am GitLab gesäit et aus wéi en Dossier, awer op der Maschinn vum Entwéckler gesäit et aus wéi en Dossier fir e spezifesche Projet. Een Niveau drënner sinn d'Komponenten déi kombinéiert ginn.
Dëst ass e Beispill vum Inhalt vun der dockeriséierter App. Mir setzen och en Docker Verzeichnis hei, an deem mir d'Konfiguratiounen ausfëllen, déi fir d'Interaktioune vun alle Komponenten erfuerderlech sinn. Et gëtt eng README.md déi kuerz beschreift wéi de Projet lancéiert gëtt.
Hei hu mir zwee Docker-Compose Dateien applizéiert. Dëst gëtt gemaach fir an Etappe lancéiere kënnen. Wann en Entwéckler mam Kernel schafft, brauch hien keng Push Notifikatiounen, hien lancéiert einfach d'Docker-Compose Datei an deementspriechend ginn d'Ressourcen gespäichert.
Wann et e Besoin fir Integratioun mat Push Notifikatiounen ass, da ginn docker-compose.yaml an docker-compose-push.yaml gestart.
Well docker-compose.yaml an docker-compose-push.yaml am Dossier sinn, gëtt automatesch en eenzegt virtuellt Netzwierk erstallt.
Beschreiwung vun Komponente. Dëst ass eng méi fortgeschratt Datei déi verantwortlech ass fir Komponenten ze sammelen. Wat ass bemierkenswäert hei? Hei presentéiere mir de Balancer Komponent.
Dëst ass e fäerdege Docker Bild dat nginx leeft an eng Applikatioun déi op den Docker Socket lauschtert. Dynamesch, wéi Container ausgeschalt ginn an ausgeschalt ginn, gëtt d'nginx Config regeneréiert. Mir verdeelen d'Handhabung vu Komponenten mat Drëtt-Niveau Domain Nimm.
Fir d'Entwécklungsëmfeld benotze mir den .dev Domain - api.informer.dev. Uwendungen mat engem .dev Domain sinn op der lokaler Maschinn vum Entwéckler verfügbar.
Da ginn d'Konfiguratiounen op all Projet transferéiert an all Projete ginn zur selwechter Zäit zesumme lancéiert.
Wa mir et grafesch duerstellen, stellt sech eraus datt de Client eise Browser ass oder eng Zort Tool, mat deem mir Ufroen un de Balancer maachen.
De Balancer bestëmmt op wéi ee Container muss zougänglech sinn op Basis vum Domain Numm.
Dëst kéint nginx sinn, wat JS dem Admin Panel ubitt. Dëst kann duerch nginx gemaach ginn, déi d'API ubitt, oder statesch Dateien, déi vum nginx a Form vu Luede Biller geliwwert ginn.
D'Diagramm weist datt d'Container mat engem virtuellen Netzwierk verbonne sinn an hannert engem Proxy verstoppt sinn.
Op der Maschinn vum Entwéckler kënnt Dir op de Container zougräifen andeems Dir d'IP kennt, awer am Prinzip benotze mir dat net. Et gëtt praktesch kee Besoin fir direkten Kontakt.
Wéi ee Beispill soll ech kucken fir meng Applikatioun ze dockeriséieren? Menger Meenung no ass e gutt Beispill dat offiziellt Docker-Bild fir MySQL.
Et ass zimlech komplizéiert. Et gi vill Versiounen. Awer seng Funktionalitéit erlaabt Iech vill Bedierfnesser ze decken, déi am Prozess vun der Weiderentwécklung entstoe kënnen. Wann Dir d'Zäit hëlt a versteet wéi et alles interagéiert, da mengen ech datt Dir keng Probleemer hutt et selwer ëmzesetzen.
Hub.docker.com enthält normalerweis Linken op github.com, wou rau Donnéeën direkt zur Verfügung gestallt ginn, vun deenen Dir e Bild selwer bauen kënnt.
Weider an dësem Repository gëtt et e Skript docker-endpoint.sh, dee verantwortlech ass fir d'initial Initialiséierung a weider Veraarbechtung vum Start vun der Applikatioun.
Och an dësem Beispill gëtt et d'Méiglechkeet vun der Konfiguratioun mat Ëmfeldvariablen. Andeems Dir eng Ëmfeldvariabel definéiert wann Dir en eenzegen Container leeft oder duerch Docker-compose, kënne mir soen datt mir en eidel Passwuert fir Docker fir Root op MySQL musse setzen oder wat mir wëllen.
Et gëtt eng Optioun fir en zoufälleg Passwuert ze kreéieren. Mir soen datt mir e Benotzer brauchen, mir mussen e Passwuert fir de Benotzer setzen, a mir mussen eng Datebank erstellen.
An eise Projeten hu mir d'Dockerfile liicht vereenegt, déi fir d'Initialiséierung verantwortlech ass. Do hu mir et un eise Besoinen ugepasst fir einfach d'Benotzerrechter auszebauen déi d'Applikatioun benotzt. Dëst huet et méiglech gemaach an Zukunft einfach eng Datebank vun der Applikatiounskonsole ze kreéieren. Ruby Uwendungen hunn Kommandoen fir Datenbanken ze kreéieren, z'änneren an ze läschen.
Dëst ass e Beispill vu wéi eng spezifesch Versioun vu MySQL op github.com ausgesäit. Dir kënnt den Dockerfile opmaachen a kucken wéi d'Installatioun do stattfënnt.
docker-endpoint.sh Skript verantwortlech fir den Entréespunkt. Wärend der initialer Initialiséierung sinn e puer Virbereedungsaktiounen erfuerderlech an all dës Aktiounen sinn am Initialiséierungsskript abegraff.
Komme mer op den zweeten Deel.
Mir sinn op gitlab gewiesselt fir Quellcoden ze späicheren. Dëst ass e relativ mächtege System deen eng visuell Interface huet.
Ee vun de Gitlab Komponenten ass Gitlab CI. Et erlaabt Iech eng Serie vu Kommandoen ze beschreiwen, déi duerno benotzt gi fir e Code Liwwersystem ze organiséieren oder automatiséiert Tester auszeféieren.
Bericht iwwer Gitlab CI 2 - de Bericht vum Ruby Russia Club ass ganz detailléiert a kann Iech interesséieren.
Elo wäerte mir kucken wat néideg ass fir Gitlab CI z'aktivéieren. Fir Gitlab CI ze starten, brauche mir just d'.gitlab-ci.yml Datei an der Root vum Projet ze setzen.
Hei beschreiwen mir datt mir eng Sequenz vu Staaten wéi Test, Deployment wëllen ausféieren.
Mir exekutéieren Scripten déi direkt den Docker-compose Build vun eiser Applikatioun nennen. Dëst ass e Beispill vu just de Backend.
Als nächst soen mir datt et néideg ass Migratiounen auszeféieren fir d'Datebank z'änneren an Tester auszeféieren.
Wann d'Skripte richteg ausgeführt ginn an kee Fehlercode zréckginn, da geet de System op déi zweet Stuf vum Deployment weider.
D'Deploymentphase ass momentan fir d'Staging implementéiert. Mir hunn keen No-Downtime Restart organiséiert.
Mir zwangsläschen all Container, an dann erhéijen mir all d'Container erëm, gesammelt an der éischter Etapp während dem Test.
Loosst eis d'Datebankmigratiounen lafen, déi vun den Entwéckler fir dat aktuellt variabelt Ëmfeld geschriwwe goufen.
Et gëtt eng Notiz datt dëst nëmmen op d'Meeschterzweig applizéiert soll ginn.
Wierkt net wann Dir aner Filialen ännert.
Et ass méiglech Rollouts laanscht Branchen ze organiséieren.
Fir dëst weider ze organiséieren, musse mir Gitlab Runner installéieren.
Dëst Utility ass a Golang geschriwwen. Et ass eng eenzeg Datei wéi et an der Golang Welt üblech ass, déi keng Ofhängegkeet erfuerdert.
Beim Start registréiere mir Gitlab Runner.
Mir kréien de Schlëssel an der Gitlab Web Interface.
Da ruffe mir d'Initialiséierungskommando op der Kommandozeil.
Gitlab Runner konfiguréieren am Dialogmodus (Shell, Docker, VirtualBox, SSH)
De Code op Gitlab Runner wäert op all Verpflichtung ausféieren ofhängeg vun der .gitlab-ci.yml Astellung.
Wéi et visuell am Gitlab an der Webinterface ausgesäit. Nodeems mir GItlab CI verbonnen hunn, hu mir e Fändel deen weist wat Staat de Bau am Moment ass.
Mir gesinn, datt viru 4 Minutten en Engagement gemaach gouf, deen all Tester gepackt huet a keng Problemer huet.
Mir kënnen d'Bauwierker méi detailléiert kucken. Hei gesi mer, datt zwee Staaten scho passéiert sinn. Testen Status an Deployment Status bei der Staging.
Wa mir op eng spezifesch Build klickt, gëtt et Konsolausgang vun de Kommandoen, déi am Prozess gestart goufen no .gitlab-ci.yml.
Dëst ass wéi d'Geschicht vun eisem Produkt ausgesäit. Mir gesinn, datt et erfollegräich Versich goufen. Wann d'Tester ofgeliwwert ginn, gi se net op den nächste Schrëtt an de Staging Code gëtt net aktualiséiert.
Wéi eng Problemer hu mir an der Inszenéierung geléist wa mir Docker implementéiert hunn? Eise System besteet aus Komponenten a mir hu misse just e puer vun de Komponenten nei starten, déi am Repository aktualiséiert goufen, an net de ganze System.
Fir dëst ze maachen, hu mir alles an getrennten Ordner ze trennen.
Nodeems mir dat gemaach hunn, hu mir e Problem mat der Tatsaach datt Docker-compose säin eegene Netzwierkraum fir all Dossier erstellt an d'Komponente vu sengem Noper net gesinn.
Fir ronderëm ze kommen, hu mir d'Netzwierk manuell am Docker erstallt. An Docker-compose gouf geschriwwen datt Dir sou en Netzwierk fir dëse Projet sollt benotzen.
Also, all Komponent, deen mat dësem Mesh ufänkt, gesäit Komponenten an aneren Deeler vum System.
Den nächste Problem ass d'Opdeelung vun der Inszenéierung tëscht verschiddene Projeten.
Well fir all dëst schéin an esou no wéi méiglech Produktioun ze gesinn, ass et gutt Port 80 oder 443 ze benotzen, déi iwwerall am WEB benotzt gëtt.
Wéi hu mir dat geléist? Mir hunn ee Gitlab Runner fir all grouss Projeten zougewisen.
Gitlab erlaabt Iech e puer verdeelt Gitlab Runners ze lancéieren, déi einfach all d'Aufgaben een nom aneren an enger chaotescher Uerdnung huelen an se lafen.
Fir Hausproblemer ze vermeiden, hu mir d'Grupp vun eise Projeten op ee Gitlab Runner limitéiert, deen ouni Probleemer mat eise Bänn ëmgeet.
Mir hunn nginx-Proxy an e separaten Startskript geplënnert an d'Gitter vun all Projeten dran geschriwwen.
Eise Projet huet ee Gitter, an de Balancer huet verschidde Gitter baséiert op Projetsnimm. Et kann Proxy weider duerch Domain Nimm.
Eis Ufroe kommen duerch d'Domain um Hafen 80 a ginn op eng Grupp vu Container geléist déi dëst Domain servéiert.
Wéi eng aner Problemer waren et? Dëst ass wat all Container als Root Standard lafen. Dëst ass de Root ongläiche Roothost vum System.
Wéi och ëmmer, wann Dir de Container gitt, wäert et root sinn an d'Datei, déi mir an dësem Container erstellen, kritt d'Rootrechter.
Wann en Entwéckler de Container erakoum an e puer Kommandoen do gemaach huet, déi Dateien generéiert hunn, dann de Container verlooss hunn, dann huet hien a sengem Aarbechtsverzeichnis eng Datei op déi hien keen Zougang huet.
Wéi kann dat geléist ginn? Dir kënnt Benotzer addéieren déi am Container sinn.
Wéi eng Problemer sinn entstane wa mir de Benotzer bäigefüügt hunn?
Wann Dir e Benotzer erstellt, passen d'Grupp ID (UID) an d'Benotzer ID (GID) dacks net.
Fir dëse Problem am Container ze léisen benotze mir Benotzer mat ID 1000.
An eisem Fall ass dëst mat der Tatsaach zesummegefall datt bal all Entwéckler Ubuntu OS benotzen. An Ubuntu OS huet den éischte Benotzer ID 1000.
Hu mir Pläng?
Liest d'Docker Dokumentatioun erëm. De Projet entwéckelt sech aktiv, d'Dokumentatioun ännert sech. Daten, déi virun zwee oder dräi Méint kritt goufen, ginn lues a lues veroudert.
E puer vun de Problemer, déi mir geléist hunn, hu vläicht scho mat Standardmëttelen geléist.
Ech wëll wierklech weidergoen an direkt op d'Orchestratioun réckelen.
E Beispill ass dem Docker säin agebaute Mechanismus genannt Docker Swarm, deen aus der Këscht kënnt. Ech géif gären eppes an der Produktioun lancéieren baséiert op Docker Swarm Technologie.
Spawning Container mécht d'Aarbecht mat Logbicher onbequem. Elo sinn d'Logbicher isoléiert. Si sinn an Containeren verstreet. Eng vun den Aufgaben ass et bequem Zougang zu Logbicher iwwer e Webinterface ze maachen.
Source: will.com