‫Zo genoeg met de aankondigingen.
‫Ik wil naar een onderwerp gaan waar ik aan heb gewerkt en waar ik me op heb gefocust vanuit mijn Node. js cursus.
‫En dat zijn omgevingsvariabelen, dus zoals je hand opsteken in de chat en je kunt trouwens in
‫de chat een dubbele punt zwaaien dubbele punt en dan zal het eigenlijk een beetje zwaaien met je hand als je te maken hebt met omgevingsvariabelen
‫in je apps en u wilt eenvoudigere manieren waarvan u niet precies weet of u
‫de beste manier doet voor omgevingsvariabelen.
‫Want daar heb ik al een tijdje mee geworsteld.
‫Ik bedoel niet alleen in containers, maar in alle gedistribueerde computers, waarbij ik ervoor moet zorgen dat al mijn apps
‫op zijn minst een consistente manier hebben om omgevingsvariabelen te doen.
‫Informatiegeheimen krijgen, je kent de server, je server DNS-namen, je weet dat je het allemaal noem maar
‫op in je containers,
‫dus goed.
‫Het lijkt er dus op dat enkelen van jullie geïnteresseerd zijn in dit onderwerp.
‫Dus dit zal deel uitmaken van mijn node. js cursus.
‫En dan ben ik van plan om er wat van te nemen en uit te zoeken hoe ik die informatie op het web kan vrijgeven.
‫Er zijn een aantal manieren waarop u dit kunt doen, maar de basis hiervan komt uit 12 factor-apps.
‫En als je nog nooit van een factor-app hebt gehoord, deze bestaat al tien
‫jaar of langer en het is een concept over 12 factoren die een gedistribueerde app in wezen succesvoller maken en het is van een bedrijf dat
‫al vroeg in de cloud en op internet heeft geleerd hoe ze moesten alle verschillende punten van
‫hun app beheren en hoe ze de verschillende zorgen moesten kennen die ze hadden over best practices, voornamelijk voor het
‫schrijven van gedistribueerde apps.
‫En de kans is groot dat als je een database op één server hebt en een API hier en een website hier en een werkfunctie
‫daar, maar laat een gedistribueerde app gelijk zijn er veel definities voor gedistribueerd dat, maar over het algemeen
‫de meesten van ons vandaag als je maakt je zorgen over containers en dat is een deel van je werk
‫en je draait ze op servers, je hebt waarschijnlijk te maken met een aantal gedistribueerde apps.
‫Het interessante hieraan is dus de configuratiestatus.
‫Dus als je teruggaat naar de twaalf-factor dot netto betaald om dit in de chat
‫te gooien, kun je deze later zeker doorbladeren en dan in elk onderwerp duiken als je daar in je app mee te maken krijgt.
‫Maar waar ik het vandaag over wilde hebben, was de configuratie en configuratie ging over het opslaan van de instellingen voor
‫uw omgeving.
‫Dus als je leert of je mijn hond- of Mastery-cursus volgt, weet je dat je nooit wilt dat je je je
‫afbeeldingen of je apps zelf hardgecodeerde instellingen hebben die voor elke omgeving anders zijn en de omgeving kan betekenen
‫dat je als een machine die de dev-testserver of de staging-server of de productieserver
‫is, of als je veel van ons leuk vindt, je hebt meerdere productieniveaus en
‫meerdere productiekopieën zoals al deze dingen.
‫Als er iets is dat daar zou kunnen veranderen, zijn dat misschien geheugeninstellingen in Java die verschillende wachtwoorden voor
‫een API kunnen zijn.
‫Verschillende sleutels die mogelijk opslagsleutels voor uw cloud kunnen zijn.
‫Het kan van alles zijn, misschien is die in uw app een kleine vlag die aangeeft op welk deel van het systeem u
‫zich bevindt en u hebt die set nodig in een eenvoudige kleine omgevingsvariabele.
‫Al die dingen moeten uit je app worden gehaald en een van de regels van twaalf factoren is of een strikte
‫scheiding van configuratie en code juist is.
‫En we hebben allemaal gezien dat we het waarschijnlijk allemaal hebben gedaan, zodat u de hardcoded waarde kent,
‫zoals lokale host, omdat uw app altijd op dezelfde server als uw database draait, maar dat is vóór containers,
‫dan ziet u mogelijk een hardgecodeerde app die zegt lokaal host in code rechts.
‫En dat is jammer, want dat maakt ze data waardoor ze erg rigide en moeilijk te hanteren zijn, want nu moet je de code
‫veranderen, alleen een veranderde omgeving, dus je wilt dat niet doen.
‫En een van de ideeën hiervan is dat apps met twaalf factoren en als je de principes van twaalf
‫factoren volgt, het heel gemakkelijk is om ze in containers te maken, de apps met twaalf factoren idealiter
‫alles gebruiken via omgevingsvariabelen.
‫De reden is dat elk besturingssysteem en elk systeem dat recht ondersteunt.
‫Als je hier een Java-app hebt en je hebt daar geen GSM en dan heb je hier een database-app die je databases
‫opslaat en je hebt een MIM die al deze dingen in de cache opslaat.
‫Elk van deze heeft een andere manier om zijn waarden te gebruiken, zijn omgevingsvariabelen goed.
‫De instellingen die het nodig heeft, de configuratie die het nodig heeft om op te starten.
‫Die zijn allemaal anders.
‫En dat kan dus behoorlijk frustrerend zijn.
‫Dus het enige dat consistent is tussen al deze variabelen, zijn omgevingsvariabelen.
‫Elke schaal ondersteunt het.
‫Windows Mac Linux ze ondersteunen allemaal dezelfde functionaliteit.
‫Het is misschien iets anders dan de manier waarop u een omgevingsvariabele instelt of wist, maar de sleutelwaarde
‫is hetzelfde en allemaal.
‫Rechts.
‫Dus dat is een kernpremisse en dat is wat je kunt zien in de hele dokter en het container-ecosysteem,
‫aangezien we dat allemaal als onze standaard hebben aangenomen.
‫Wat ik bedoel, is dat als je bijvoorbeeld een applicatie hebt met een demobestand of
‫een I en I of een ander soort configuratiebestand waar de waarden naar toe moeten, dan moet je een middelste
‫laag tussen de omgevingsvariabelen schrijven en dan waar ze naar de app gaan.
‫Rechts.
‫En daar heb ik een voorbeeld van in mijn niet zo complete BHP app.
‫Dus op GitHub in mijn PSP-app laten afbeeldingen je een snel letterlijk voorbeeld zien.
‫En dan gaan we naar je vragen.
‫Dus hier heb ik een docker-bestand en deze opoffering, er zijn veel dingen, maar de dingen
‫waar ik me op wil concentreren, is in deze app op dit niveau. Ik heb standaardinstellingen die ik in het docker-bestand instel
‫voor omgevingsvariabelen.
‫De reden en de manier waarop ik ze hier instel, is dat ik er de voorkeur aan geef dat de instellingen hier standaard werken in
‫een productieomgeving, aan jou, of je nu zegt, kijk, deze standaardwaarden zijn gewoon de gemiddelde productiewaarden of misschien
‫wel zeg hallo, dit zullen de gemiddelde ontwikkelaarswaarden zijn. Ik geef er
‫de voorkeur aan dat ze een beetje in gebreke blijven aan de productiekant van dingen, op die manier kan ik ze overschrijven met een
‫samengesteld bestand lokaal op mijn lokale machine, geen probleem, maar het is aan jou
‫hoe je doe dat, maar je wilt hier zeker consistente maken die vanaf het begin logisch zijn.
‫Nu ga je veel van deze overschrijven met andere manieren om het in te stellen, hetzij
‫via het docker run-commando of door een zwerm of een Cubaanse netwerkimplementatie in te zetten, of in je Ducker compose GMO-bestand zul je
‫die overschrijven.
‫Rechts.
‫Je kunt deze zelfs in de shell overschrijven voordat je die commando's uitvoert en het zal die naar binnen zuigen.
‫Je kunt ook met iets als Docker componeren een dot EMV-bestand instellen dat in de PSP-wereld eigenlijk
‫een standaard is waarmee het ook in de gok zal werken.
‫Dus je kunt zien dat ik deze hier heb, maar sommige hiervan gaan natuurlijk naar de app, ze kunnen in verschillende
‫bestanden terechtkomen en laten we even een back-up maken en ik zal je het
‫volgende deel laten zien.
‫Dus die zijn ingebed in het doktersbestand wanneer de afbeelding nu wordt gemaakt.
‫Als ik naar mijn doktersbestand wil kijken, wordt dit gebruikt voor lokale instellingen.
‫Als ik aan het ontwikkelen ben en dan kan ik hier doorheen kijken en je kunt zien dat ik ze allemaal
‫instel en misschien ook wel anders.
‫Ik hoef ze niet te negeren als ik dat niet wil.
‫Maar in dit geval kies ik ervoor om soortgelijke als voorbeeld te stellen.
‫Als ik de afbeeldingen in de afbeelding niet hoefde te negeren, zou ik er misschien veel met rust laten.
‫Dus dat is er.
‫Oke.
‫Dus ik stel ze hier in en nu zullen deze worden gebruikt bij het opstarten van containers.
‫Dus als ik ze wil wijzigen, moet ik de container opnieuw opstarten.
‫Ik hoef het containerrecht niet te verwijderen.
‫Ik moest hem gewoon opnieuw opstarten.
‫Je kunt dus dr. samengesteld om dat te doen, dan is de volgende stap misschien eens
‫kijken, misschien op mijn lokale machine of zelfs in productie. Ik wil dat die in specifieke bestanden staan.
‫Rechts.
‫Dus als mijn kind mijn applicatie opstart, moeten die omgevingsvariabelen ergens anders zijn.
‫Ze kunnen voor sommige apps niet zomaar in omgevingsvariabelen leven.
‫Ik zou deze legacy-apps of traditionele apps noemen waar ze standaard niet naar omgevingsvariabelen
‫kijken.
‫Als ik nu een nieuwe app zou maken, zou mijn doel zijn dat die naar omgevingsvariabelen kijkt en
‫misschien is er een configuratiebestand of iets dat de app gebruikt, maar ik overschrijf die met omgevingsvariabelen
‫automatisch.
‫Dus het idee is dat mijn app slim genoeg is om te zeggen hey als er geen omgevingsvariabele voor is,
‫zal ik deze standaard uit dit bestand gebruiken.
‫Maar als er al een set omgevingsvariabelen is, zal ik die gebruiken.
‫Als je bekend bent met zwerm en Cubaans net, weet je dat als we eenmaal in
‫de geheimen komen en configureren, we kunnen beginnen die hele bestanden te overschrijven en wachtwoorden en geheimen als individuele bestanden te verstrekken.
‫Dus misschien wilt u ook dat uw app hiervan op de hoogte is.
‫Maar als je app niet je eigen aangepaste app bouwt of misschien dingen van Docker
‫Hub of officiële open source gebruikt, dan moet je kijken naar een toegangspuntscript.
‫De manier waarop het wordt uitgevoerd, is in uw afbeelding. U stelt het startpuntscript in dat u wilt uitvoeren en het
‫zal dat uitvoeren bij het opstarten.
‫En wat je hier kunt zien, is een heel eenvoudig voorbeeld van hoe ik de gewelddadige variabelen en enkele andere hardgecodeerde
‫gegevens bij het opstarten in een specifiek bestand schrijf, gewoon met behulp van een bash-script.
‫Rechts.
‫Moet wel chique zijn.
‫Je kunt ook andere methoden gebruiken om dit te doen, maar het staat meestal in de officiële afbeeldingen van de docker.
‫Deze app is meestal de standaard.
‫Oke.
‫Dus in dit geval neem ik omgevingsvariabelen die zijn ingesteld in het docker-bestand of het
‫compose-bestand die het Docker-bestand van de afbeelding overschreven, het zal die Passim hierheen brengen en dan zal dit dat spul
‫naar een bestand echoën.
‫Het gaat om imago.
‫Dit is dus voor een oudere HP-app die een p HP FP M-configuratiebestand verwacht en ik moet bepaalde configuratiewaarden voor NPM
‫instellen die in dit geval uniek zijn voor elke omgeving.
‫Dit is eigenlijk hoeveel ik wil dat het FGM-systeem groeit en hoeveel subprocessen ik dat soort dingen
‫wil voortbrengen.
‫Rechts.
‫Dus dat zou anders zijn op de lokale ontwikkeling versus productie op productie. Ik wil dat het
‫veel groeit.
‫Rechts.
‫Dus je zou die dingen hier veranderen en dit is hoe je die legacy-apps neemt en ze laat werken.
‫Nu kun je dit spul in officiële afbeeldingen zien, want zo leer ik van veel van mijn dingen.
‫Dus als ik net in het vervolg ben gegaan, kun je zien hoe ze het deden, wat precies dezelfde manier is waarop
‫mijn vervolg dingen nodig heeft in een configuratiebestand.
‫Rechts.
‫Het heeft instellingen nodig die dynamisch zijn tijdens runtime.
‫Dus als je in het docker-bestand keek voor het officiële mijn vervolg en je scrolt naar beneden, je zult zien dat het hier inderdaad een aantal omgevingsvariabelen instelt, maar
‫het heeft ook een toegangspuntscript dat het daarin kopieert en het koppelt aan een specifieke locatie
‫en dan is het zoals het is het ingangspunt.
‫Dus het commando hier is het zien van de CMB, je kunt het niet echt zien.
‫De CMB is alleen voor mijn vervolg, het toegangspunt dat technisch wordt uitgevoerd, is daarvoor en dan wordt de uitvoering doorgegeven aan
‫de CMT.
‫Zodra dat script klaar is, is de manier waarop ik dat script hier vind, ik ga
‫gewoon een niveau omhoog en krijg hub en ik klik op dit achtste punt, dus en dan zie ik
‫een
‫omgevingsvariabele, zie en nu hebben we het shellscript dat wordt uitgevoerd elke keer dat mijn vervolg goed begint.
‫En hier doet het dingen zoals omgevingsvariabelen nemen en beschikbaar maken voor de app.
‫In feite is het slim genoeg dat als je een klein onderstrepingsbestand toevoegt aan het einde van een omgevingsvariabele,
‫het alles in dat bestand zal nemen en het in de omgevingsvariabele zal veranderen, wat geweldig is voor alle applicaties die nog
‫steeds geheimen nodig hebben, een API-sleutels en al dat soort dingen.
‫En als je zwermgeheimen of geheimen van Cubaanse entiteiten gebruikt, worden die dingen verstrekt omdat ze als bestanden kunnen
‫worden verstrekt.
‫Nu kun je altijd dingen gebruiken zoals kluis en andere mooie systemen die eerlijk op bestanden zijn gebaseerd, maar in containers hebben
‫we de neiging om dingen als bestanden te gebruiken en Linux in het algemeen gebruiken we dingen dan als bestanden.
‫Dus je geeft deze dingen door als individuele bestanden.
‫En dan dit kleine stukje shellscript dat open source is, wat betekent
‫dat je het kunt kopiëren en in je app kunt plaatsen. Je kunt dat gebruiken om de omgevingsvariabelen uit het tekstbestand te kopiëren en
‫ze vervolgens elk in een omgevingsvariabele met de naam te plakken op de juiste manier en op die manier kan
‫de app later omgevingsvariabelen hebben die in configuratiebestanden voor de app worden geschreven en alles is geweldig.
‫Rechts.
‫En dit zou bij elke start van de app veranderen omdat de inherente variabelen anders kunnen zijn.
‫En dan zou het die herschrijven en zo werkt dat.
‫Dus hopelijk begrijp je die stappen.
‫Er komt veel meer bij kijken.
‫Er is eigenlijk een laat me je heel snel pakken.
‫Er is een geweldige kleine samenvatting van het omgaan
‫met omgevingsvariabelen in het artikel dat ik heb geschreven, zelfs de link hier.
‫Ja, dit is voorbij op de Riley-site.
‫En ik heb een leuk blogartikel voor ze gemaakt.
‫Nou, ik vind het wel mooi.
‫Maar je weet dat het aan jou is om te zeggen dat je ons leugens moet vertellen.
‫En het gaat over dr. Campos omdat veel van waar we voor ontwikkelaars mee te maken
‫hebben, vooral de lokale configuratie is.
‫Hoe maak ik mijn configuratie specifiek voor mij.
‫En een van die dingen is een override-bestand dat ik helaas niet heb in dit HP-voorbeeld. Ik denk niet
‫dat ik geen override-bestand heb, maar dat zou ik wel moeten doen.
‫Dat zou nog iets zijn om hier aan toe te voegen.
‫Maar hier zal ik dat in toom houden.
‫Controleer die O'Reilly-link om over drie verschillende dingen te praten en samen te
‫stellen die je echt zullen helpen je spel te verbeteren bij het beheren van de configuratie en het verminderen van gerepliceerde delen. Juiste
‫sjablonen betekenen dat je specifieke delen bovenaan je samengestelde bestand kunt toevoegen en dan herhalen zonder te hoeven herhaal
‫deze keer op keer, dus als je veel van dezelfde omgevingsvariabelen hebt omdat je microservices doet en
‫je hebt misschien 20 microservices in een samengesteld bestand, is sjablonen iets voor jou.
‫Dit is iets anders dat je echt wat tijd zal besparen en je kunt dezelfde
‫delen die steeds opnieuw moeten worden herhaald helemaal bovenaan je opstelbestand hebben en dan
‫is dit gewoon een gok, echt het sjabloneren en dan u kunt dat dan op het juiste moment op elke
‫service invoegen.
‫Zoals ik hier doe, staan hier ook andere dingen in. Ik moedig je aan
‫om dat te bekijken, inclusief hoe je de omgevingsvariabelen in samengestelde bestanden gebruikt, niet alleen voor het instellen van
‫omgevingsvariabelen in de afbeelding, maar ook voor al het andere dat je wilt veranderen in je config-bestand tijdens runtime, dus controleer
‫dat.
‫Ik hoop dat je het leuk vindt Michiel.
‫Wat is er Michiel.
‫Michael Ahrens aan het bellen.
‫Bel mij.
‫Wat is dat voor telefonische vergadering daar.
‫dr. Kapitein.
‫Vaak wat niet in omgevingsvariabelen mag.
‫Wie ben je aan het lokken.
‫De vraag.
‫Om te zien waar mensen mee komen.
‫Wat mag niet in omgevingsvariabelen worden opgenomen.
‫Welnu, de redenen waarom Docker en Cubaanse entiteiten en andere tools deze manieren voor ons hebben gecreëerd om geheimen in
‫de bestanden te plaatsen, is dat ze geen omgevingsvariabelen hoeven te zijn.
‫Dus idealiter als je je eigen apps maakt voor het beheren van je eigen apps, houd je
‫die geheimen buiten de omgevingsvariabelen, niet omdat omgevingsvariabelen noodzakelijkerwijs inherent onveilig zijn, maar omdat
‫we met omgevingsvariabelen de neiging hebben om ze goed te lekken.
‫Ze hebben de neiging om in logboeken te verschijnen, omdat we misschien een dump van omgevingsvariabelen ergens
‫in onze configuratie doen of dat doen we.
‫Als je niet van een P HP hield, was er een ap HP-testopdracht PSP EMV of ik kwam binnen zoals het heet meer iemand waarvan ik
‫zeker weet dat hier is en onthoud en vertel me maar waar het je configuratie naar een web
‫zal dumpen pagina zijn er dat soort dingen en als er dan geheimen zijn in omgevingsvariabelen, zullen ze daar worden
‫onthuld en het is misschien niet je bedoeling dat ze op de een of andere manier in logs of
‫in het monitoringsysteem lekken en jij.
‫Als je fouten hebt, weet je soms of je ooit applicaties hebt gehad waar als je het instelt om te debuggen
‫en fouten uit dit de ware ding is in dot net waar het dan een hele
‫reeks variatie op het scherm zal plaatsen en omgevingsvariabelen zou kunnen lekken op het scherm omdat je bent
‫vergeten het in de productiemodus te vergrendelen, zijn er allerlei manieren waarop omgevingsvariabelen in verkeerde handen kunnen komen.
‫Dus een goede eerste stap om dingen niet in omgevingsvariabelen te plaatsen, zijn de geheimen en met swarm en
‫communities kun je die in bestanden bewaren en op die manier kun je je app leren hoe ze ze gewoon uit de
‫bestanden kunnen halen.
‫De volgende stap ben jij als je ze van je geheimen en configuratiebestanden kunt krijgen in de bestanden die de app nodig
‫heeft.
‫Dus in plaats van een omgevingsvariabele op te slaan die dan uiteindelijk wordt zoals ik zou moeten, wordt bijvoorbeeld uiteindelijk geschreven
‫naar een bestand dat je zou kunnen gebruiken, kan figs en de configuratie en geheimen en bestanden opslaan en dan gaan ze rechtstreeks naar
‫de bestanden die misschien mijn vervolg of je app nodig hebben .
‫Rechts.
‫Dus technisch gezien komen ze nooit in omgevingsvariabelen.
‫Dus in ieder geval niet op de server zelf.
‫Rechts.
‫Dus dat is een geweldig onderwerp, ik ben blij dat je dat ter sprake brengt.
‫Maar het punt is dat ik waarschijnlijk een hele cursus zou kunnen schrijven over configuratiegeheimen, omgevingsvariabelen, maar eigenlijk alle dingen
‫die je nodig hebt voor een omgeving en hoe ermee om te gaan.
‫Rechts.
‫En ik denk dat we zelfs als je naar dingen als kluis gaat voor je en nu je het hebt over een geheime
‫API die je noemt, het nog ingewikkelder wordt.
‫Dus er is zeker veel om over te praten.
‫En als iemand goede bronnen heeft die ze leuk vinden, aarzel dan niet om ze te gooien en te chatten of ze
‫in de opmerkingen van de YouTube-video te gooien voor later.
‫Oké, goede vraag Michael, goed je te zien.
‫Waarom zou je.
‫Stephen zegt: Zou je Ducker-bestand niet onder bronbeheer hebben, hoewel ik er geen voorstander van ben om productiegegevens
‫te hebben, zoals een gebruikersnaam, wachtwoord en bronbeheer.
‫Daarom zijn die waarden gewoon standaardwaarden in je doktersdossiers Steven.
‫Je zou geen echte geheimen in dat dossier stoppen.
‫Rechts.
‫Zoals je in mijn voorbeeld kunt zien, staat hier alles in het dolkbestand slechts voorbeelden of
‫voorbeelden.
‫Als het een eenvoudig getal is of iets dat gewoon moet worden ingesteld en er is een standaard, een soort redelijke standaard zoals
‫deze hier deze p p p. m. instellingen, plaats dan zeker de productie-instellingen die u
‫verkiest en dan kunt u ze overschrijven als dat nodig is.
‫Zo hoef je ze niet elke keer handmatig in te stellen.
‫Maar ja, als je hier naar een van deze gaat die uniek zijn voor een specifieke app of een specifieke
‫omgeving, voer ik hier gewoon dummy-waarden in.
‫Ik heb dat zeker niet aanbevolen in je coderepository.
‫Je voert je geheimen in en je URL's en omgeving, je kent de domeinnaaminstellingen en dat soort
‫dingen.
‫Oke.
‫Ik ben het ermee eens, maar je Ducker-bestand zelf zou in je app zitten.
‫Ja, daar wil je het houden.
‫Oke.
‫Goede vraag.
‫Goede vraag ja.
‫Ik bedoel, tenzij ze goed gecodeerd zijn, zou je ze kunnen hashen als je app dat soort dingen
‫accepteert.
‫Maar ik zou ze er nog steeds niet in houden.
‫Ik bewaar de omgevingsinstellingen niet ergens anders, maar je hebt wel standaardinstellingen nodig.
‫En wat ik meestal doe in een samenstellingsbestand met Docker compose, is dat ik standaardinstellingen instel die direct met een
‫lokale ontwikkelaar werken.
‫Dus Docker componeren zou gewoon voor hen werken.
‫Nu kan het betekenen dat ze een punt in het V-bestand ergens anders vandaan moeten halen, misschien een beveiligde winkel
‫waar je een soort ontwikkelaarsgeheimen hebt, dat soort dingen weet je.
‫Maar ik werk er echt hard aan om dat ook niet op te nemen, zoals idealiter als je een lokale ontwikkelaar bent, je alles hebt
‫wat je lokaal nodig hebt.
‫Je hebt geen externe api nodig als externe dingen en je hebt hopelijk voorbeeldgegevens en dingen die gewoon op je lokale
‫computer kunnen staan en je hebt niet veel geheimen nodig waar je je zorgen over hoeft te maken,
‫je hebt gewoon dummy-waarden voor alles en je kunt gewoon lokaal kopen.
‫Uiteraard kunnen niet al onze apps dat als een soort utopie.
‫Dus je gaat een andere manier bedenken om die geheimen
‫op te slaan en daarom zijn er zoveel manieren om omgevingsvariabelen tijdens runtime in te
‫stellen, zodat je ze ergens anders kunt bewaren en ze dan op het laatste moment via de omgeving binnen kunt krijgen variabelen oke goede vragen over omgevingswerkwoorden.
‫Ik ben blij dat we dit onderwerp vandaag hebben.
‫Laten
‫we eens kijken wat de eenvoudigste manier is om het E- en V-bestand te implementeren.
‫Ook liet ik je het voorbeeld van de my sequel-app zien.
‫En hier nemen ze dit script en er is geen EMV-bestand.
‫Waar dit voor is ontworpen, is wanneer u geheimen of configuratie gebruikt.
‫Dus als je de native geheimen en configuratiefuncties van Docker-swarm- of configuratiekaarten en -geheimen in communities
‫gebruikt, zou je dit misschien gebruiken als een manier om die informatie uit die bestanden te krijgen, met name de
‫geheimen, en ze in omgevingsvariabelen te krijgen.
‫Als je ze goed nodig hebt, hoef je ze misschien niet in omgevingsvariabelen te krijgen, maar als je dat deed,
‫zou je dit kleine shellscript kunnen gebruiken om dat te doen.
‫Ik hoop dat dat je vraag beantwoordt, maar dat zou ik niet zijn.
‫Het is niet nodig om een specifiek bestand aan te maken.
‫Precies.
‫Als je het hebt over hoe je zwermgeheimen kunt doen, omdat zwermgeheimen bestanden voor je maken,
‫bekijk dan mijn Docker-beheersingscursus op de URL.
‫Brett Fisher dot com slash talker die in de beschrijving staat.
‫Daar heb ik het daar ook over gehad in mijn zwermcursus.