Zelf een con­tai­ner ma­ken voor ei­gen en nieu­we ser­vi­ces

Zelf een con­tai­ner ma­ken voor be­staan­de en nieu­we ser­vi­ces

C’t Magazine - - Inhoud - Mir­ko Dö­l­le

Doc­ker is een han­di­ge op­los­sing voor pro­ble­men die tot nu toe op een an­de­re ma­nier op­ge­lost wer­den. We la­ten zien hoe je je MySQL­da­ta­ba­se in een con­tai­ner zet en hoe je met Tor en de P2P-mes­sen­ger Bit­mes­sa­ge in een con­tai­ner vei­lig in het darknet com­mu­ni­ceert. Daar­bij leer je ook te wer­ken met con­tai­ners die met el­kaar in ver­bin­ding staan.

Ou­de wijn in nieu­we zak­ken? Dat zou je kun­nen den­ken als je kijkt naar de ser­vi­ces die sys­teem­be­heer­ders te­gen­woor­dig in Doc­ker­con­tai­ners heb­ben draai­en: web­ser­vers, con­tent­ma­na­ge­ment­sys­te­men, da­ta­ba­ses, dat soort din­gen. Nieuw is al­leen dat de ser­vi­ces nu niet meer naast el­kaar op de ser­ver uit­ge­voerd wor­den, maar dat el­ke ser­vi­ce apart – af­ge­schermd van de an­der – in een Doc­ker-con­tai­ner draait. Wel moe­ten ze nog steeds met be­paal­de an­de­re ser­vi­ces blij­ven sa­men­wer­ken. Het be­lang­rijk­ste pro­bleem is dan ook meest­al dat ser­vi­ces naar Doc­kers ge­mi­greerd moe­ten wor­den, maar wel nog steeds bij con­fi­gu­ra­tie­be­stan­den en an­de­re ge­ge­vens moe­ten kun­nen.

Kant-en-klaar

Voor­dat je een ei­gen Doc­ker-ima­ge in el­kaar gaat zet­ten, moet je al­tijd eerst in Doc­ker Hub con­tro­le­ren wat er al be­staat. Het wiel hoeft im­mers niet voor de mil­joen­ste keer te wor­den uit­ge­von­den. Het bes­te voor­beeld is MySQL: de 'of­fi­ci­ë­le' MySQL-ima­ge uit Doc­ker Hub wordt goed on­der­hou­den en hoef je daar­door zo goed

als niet aan te pas­sen. Als je geen ei­gen pat­ches voor de da­ta­ba­se no­dig hebt, zal je ei­gen cre­a­tie niet veel be­ter zijn dan de ima­ge die in Doc­ker Hub staat – en kun je dus be­ter die pak­ken.

Het is niet moei­lijk om een lo­ka­le MySQL-in­stal­la­tie naar een MySQL-con­tai­ner te mi­gre­ren: eerst stop je MySQL op de lo­ka­le host, zo­dat in de da­ta­ba­se geen wij­zi­gin­gen meer wor­den aan­ge­bracht. Ver­vol­gens maak je een ko­pie van de map /var/lib/mysql met de MySQL-ge­ge­vens. Met die map zal de con­tai­ner gaan wer­ken.

Er zijn twee ma­nie­ren om de ko­pie op te slaan: laat Doc­ker je ge­ge­vens in vo­lu­mes be­he­ren of zet je con­tainer­ge­ge­vens in een apar­te map. Bei­de me­tho­den wor­den hier­on­der be­schre­ven.

Als je je MySQL-da­ta­ba­se naar een vo­lu­me ko­pi­eert, maak je die eerst aan met het vol­gen­de com­man­do:

doc­ker vo­lu­me cre­a­te lo­cal­mysql

Doc­ker maakt daar­mee in de map vo­lu­me de sub­map lo­cal­mysql/_da­ta aan voor je ge­ge­vens. Daar­naast wordt voor het vo­lu­me in de vo­lu­me­da­ta­ba­se een nieuw re­cord aan­ge­maakt. Om te ach­ter­ha­len waar de map met da­ta pre­cies staat, moet je dit com­man­do uit­voe­ren:

doc­ker vo­lu­me in­spect lo­cal­mysql

Ko­pi­eer je hui­di­ge MySQL-da­ta­ba­se daar­heen, of­te­wel de com­ple­te in­houd van de map /var/lib/mysql.

Vluch­ti­ge vo­lu­mes

Doc­ker-vo­lu­mes heb­ben twee na­de­len. Het eer­ste is dat je geen af­zon­der­lij­ke be­stan­den uit een vo­lu­me op een be­paal­de plek in de con­tai­ner kunt moun­ten, om bij­voor­beeld het con­fi­gu­ra­tie­be­stand voor MySQL te ver­van­gen door een ei­gen. Je zou dan meer­de­re vo­lu­mes voor de­zelf­de con­tai­ner moe­ten ma­ken, maar daar­mee wordt het snel on­o­ver­zich­te­lijk.

Het twee­de na­deel is dat je ge­ge­vens in een hand­om­draai on­her­roe­pe­lijk kunt ver­lie­zen. Dat kan bij­voor­beeld ge­beu­ren als je voor een up­gra­de de ou­de con­tai­ner al ge­wist hebt en ver­vol­gens gaat op­rui­men met het com­man­do doc­ker vo­lu­me pru­ne. Doc­ker vraagt dan wel of je echt wilt op­rui­men, maar ver­telt niet wel­ke vo­lu­mes ge­wist wor­den. Op die ma­nier zijn com­ple­te be­drij­ven al per on­ge­luk in rook op­ge­gaan.

Als je een ei­gen di­rec­to­ry aan een con­tai­ner mee­geeft, zal dat je niet over­ko­men en kun je je ge­ge­vens ook over­zich­te­lijk struc­tu­re­ren – bij­voor­beeld door de map /da­ta/lo­cal­mysql als ba­sis­pad voor al­le con­fi­gu­ra­tie- en da­ta­ba­se­be­stan­den van je MySQL-ser­ver te ge­brui­ken. Daar­na moet je dan nog de con­fi­gu­ra­tie­be­stan­den in /da­ta/lo­cal­mysql/con­fig zet­ten en je hui­di­ge MySQL-da­ta­ba­se ko­pi­ë­ren naar /da­ta/ lo­cal­mysql/da­ta.

Voor­dat je de MySQL-con­tai­ner de eer­ste keer start – on­ge­acht of je met Doc­ker-vo­lu­me werkt of met een ei­gen map – moet je er­voor zor­gen dat de juis­te ei­ge­na­ren en toe­gangs­rech­ten voor je ou­de be­stan­den ge­con­fi­gu­reerd zijn. Het is niet al­tijd mak­ke­lijk om daar ach­ter te ko­men. Soms is het het een­vou­digst om een twee­de con­tai­ner te star­ten met een niet voor­af ge­maakt Doc­ker-vo­lu­me en een an­de­re naam:

doc­ker run --na­me mysql­test \ -v mysql­test:/var/lib/mysql \ -e MYSQL_ROOT_PASSWORD=123456 \ -d mysql:8

Om­dat het Doc­ker-vo­lu­me mysql­test nog niet be­staat, ge­ne­reert Doc­ker tij­dens de start van de con­tai­ner een nieuw vo­lu­me met die naam. De be­stan­den die al in de con­tai­ner staan (in de map /var/lib/mysql) wor­den naar het nieu­we vo­lu­me ge­ko­pi­eerd. Met doc­ker vo­lu­me in­spect mysql­test ach­ter­haal je het pad van het vo­lu­me en kun je zien wie de ei­ge­naar van de be­stan­den is en wel­ke rech­ten die heeft. Ook kun je de­ze ge­ge­vens voor je ou­de be­stan­den aan­pas­sen.

De test­con­tai­ners en -vo­lu­mes heb­ben hun werk daar­mee ge­daan. Je kunt ze als volgt weer ver­wij­de­ren:

doc­ker stop mysql­test doc­ker rm mysql­test doc­ker vo­lu­me rm mysql­test

Af­ge­ke­ken

Een an­de­re me­tho­de is door de Doc­ker­fi­le van de ima­ge in Doc­ker Hub te be­kij­ken. Daar wordt voor MySQL een nieu­we ge­brui­ker aan­ge­maakt: RUN grou­padd -r mysql && \ use­radd -r -g mysql mysql

De pa­ra­me­ters -r na grou­padd en use­radd be­te­ke­nen dat een sys­teem­ge­brui­ker res­pec­tie­ve­lijk sys­teem­groep met een id on­der 1000 aan­ge­maakt wor­den. De­bi­an telt daar­bij stan­daard af. De eer­ste sys­teem­ge­brui­ker die op die ma­nier wordt aan­ge­maakt, krijgt als id dus 999. De da­ta in het vo­lu­me ho­ren steeds tot de­zelf­de groep, na­me­lijk tot de groep doc­ker. In het ge­val van een MySQL-con­tai­ner be­te­kent dit dat je de vo­lu­me- of data­di­rec­to­ry moet be­wer­ken met

chown -R 999:doc­ker *

Daar­na kan de MySQL-con­tai­ner bij de da­ta.

Om de MySQL-con­tai­ner met de da­ta­ba­se­be­stan­den in de map /da­ta/lo­cal­mysql te star­ten, moet je het ab­so­lu­te pad van de map als bron ach­ter de pa­ra­me­ter -v aan­ge­ven. Daar­na volgt de doel­map in de con­tai­ner:

doc­ker run --na­me lo­cal­mysql -v \ /da­ta/lo­cal­mysql/da­ta:/var/lib/mysql \ -d mysql:8

Je hoeft niet per se het root­wacht­woord voor MySQL met een om­ge­vings­va­ri­a­be­le aan te ge­ven. Je MySQL-da­ta­ba­se is im­mers al ge­con­fi­gu­reerd en met een wacht­woord be­vei­ligd. Met doc­ker net­work in­spect brid­ge kom je ach­ter het ip-adres van de MySQL-con­tai­ner. Met dat adres kun je de da­ta­ba­se voort­aan be­rei­ken. Je kunt de con­tai­ner ook met een vast ipadres in een User De­fi­ned Net­work op­ne­men – meer daar­over lees je in het ar­ti­kel op pa­gi­na 122.

Stap voor stap

De kwa­li­teit van de ima­ges in Doc­ker Hub is af en toe du­bi­eus, met na­me re­gel­ma­ti­ge of zelfs au­to­ma­ti­sche up­da­tes vor­men een pro­bleem. Je kunt dan nog al­tijd de Doc­ker­fi­le als ba­sis voor een ei­gen cre­a­tie ge­brui­ken. De Doc­ker­fi­le is een soort re­cept waar­op al­le in­gre­dien­ten en stap­pen voor het ma­ken van een Doc­ker-ima­ge be­schre­ven staan. Bij de vol­gen­de stap ont­staat dan een kan­ten-kla­re con­tai­ner.

Maak in­dien mo­ge­lijk he­le­maal geen ge­bruik van ei­gen ima­ges, maar ga voor een van de ba­sis­ima­ges. Zelf ge­brui­ken we als ba­sis meest­al een Al­pi­ne- of De­bi­a­nima­ge. Daar­op ba­se­ren we on­ze Doc-

ker­fi­les voor bij­voor­beeld een con­tai­ner met een Tor-dae­mon. Nor­maal draait de Tor-dae­mon di­rect op de host en tun­nelt die naar het darknet. Mocht er een ern­stig be­vei­li­gings­lek be­kend wor­den, dan zou dat met­een ge­vaar voor de host kun­nen op­le­ve­ren. Door Tor in een con­tai­ner on­der te bren­gen, wordt het voor een po­ten­ti­ë­le aan­val­ler moei­lij­ker.

Als ba­sis voor de Tor-ima­ge dient Al­pi­ne Li­nux, ver­sie Ed­ge. Daar­op moet Tor wor­den ge­ïn­stal­leerd en zo­da­nig ge­con­fi­gu­reerd dat Tor als SOCKS5-proxy voor ver­bin­din­gen naar het darknet be­schik­baar is. Er be­staat geen hand­lei­ding voor het in­stal­le­ren van Tor, maar in de Al­pi­ne­re­po­si­to­ry is wel een Tor-pak­ket te vin­den. De rest moet je zelf uit­zoe­ken.

Om dat goed te doen, is een draai­en­de Al­pi­ne Li­nux-con­tai­ner waar­in je de no­di­ge soft­wa­re in­stal­leert en con­fi­gu­reert een goed be­gin. Je kunt de com­man­do's la­ter ge­woon in de Doc­ker­fi­le aan­vul­len. In het be­gin be­staat de Doc­ker­fi­le uit slechts twee re­gels:

FROM al­pi­ne:ed­ge CMD /bin/sh

Met het com­man­do doc­ker build -t tor ./ ge­ne­reer je de ima­ge tor uit de Doc­ker­fi­le en start je hem met doc­ker run -it --rm tor. Daar­mee kom je in de stan­daard-shell van het Al­pi­ne-sys­teem.

Om Tor via het pak­ket­be­heer te in­stal­le­ren, moet je eerst met apk up­da­te de pak­ket­lijs­ten bij­wer­ken. Daar­naast moet je met apk up­gra­de al­le klaarstaan­de up­da­tes in je ima­ge in­stal­le­ren. De Al­pi­ne-ima­ge in Doc­ker Hub wordt na­me­lijk niet voor el­ke klei­ne pak­ketup­da­te op­nieuw ge­maakt. De ba­sis­ima­ge kan daar­door dus nog be­vei­li­gings­lek­ken be­vat­ten waar­voor al­lang fixes be­staan.

Ver­vol­gens in­stal­leer je de Tor-dae­mon met het com­man­do apk add tor, waar­bij af­han­ke­lijk­he­den au­to­ma­tisch mee­ge­no­men wor­den. Daar­mee heb je Tor ge­ïn­stal­leerd en kun je de Doc­ker­fi­le aan­vul­len:

FROM al­pi­ne:ed­ge

RUN apk up­da­te && \ apk up­gra­de && \ apk add tor CMD /bin/sh

Pro­beer de Doc­ker­fi­le uit door op­nieuw het com­man­do doc­ker build -t tor ./ uit te voe­ren. Start daar­na met doc­ker run -it --rm tor een Tor-con­tai­ner. Om­dat Tor al kant-en-klaar ge­ïn­stal­leerd is, hoef je voor het star­ten van de Tor-dae­mon al­leen maar tor in te voe­ren.

Daar­mee heb je met­een ook al de laat­ste be­no­dig­de com­po­nent voor de Doc­ker­fi­le aan­ge­kon­digd: het en­try­po­int. Dat pro­gram­ma wordt uit­ge­voerd als de con­tai­ner start. Als het pro­gram­ma beëindigd wordt, wordt ook de con­tai­ner af­ge­slo­ten. Daar­om is het be­lang­rijk voor­grond­pro­ces­sen als en­try­po­int te se­lec­te­ren. Bij som­mi­ge dae­mons heb je daar een spe­ci­a­le pa­ra­me­ter voor no­dig, bij an­de­re is weer een wrap­per-script ver­eist dat de ge­wens­te ser­vi­ce op­start en per­ma­nent be­waakt. Om­dat de Tor-dae­mon als voor­grond­pro­ces start, hoef je al­leen maar CMD /bin/sh te ver­van­gen door EN­TRY­PO­INT ["tor"].

Daar­mee draait Tor ech­ter ook met root­rech­ten en kan een even­tu­e­le in­drin­ger dus nog meer aan­val­len uit­voe­ren. De Tor-dae­mon heeft he­le­maal geen root­rech­ten no­dig, je kunt hem pro­bleem­loos als ge­brui­ker tor star­ten – daar­voor moet je in de Doc­ker­fi­le voor het en­try­po­int de ter­men USER tor toe­voe­gen. De vol­le­di­ge Doc­ker­fi­le staat in het ka­der links­on­der op de vo­ri­ge pa­gi­na. Voer je nog een keer doc­ker build -t tor ./ uit, dan wordt de bij­ge­werk­te con­tai­ner ge­ge­ne­reerd.

Ex­tern ge­con­fi­gu­reerd

Dan moet je nog het con­fi­gu­ra­tie­be­stand /etc/tor/tor­rc aan­pas­sen om naast de SOCKS-proxy even­tu­eel la­ter ook zo­ge­naam­de hi­d­den-ser­vi­ces – ser­vi­ces in het darknet – te kun­nen con­fi­gu­re­ren. Je kunt daar­bij als uit­gangs­punt het be­stand /etc/ tor/tor­rc.sam­ple uit de con­tai­ner ge­brui­ken. Je roept dat bij­voor­beeld op met dok­ker exec en cat. Als eni­ge aan­vul­ling zet je daar nog SOCKSPort 9050 bij.

Om te voor­ko­men dat je steeds een nieu­we con­tai­ner moet ma­ken, moet je het con­fi­gu­ra­tie­be­stand en de di­rec­to­ry /var/lib/tor, waar­in de Tor-dae­mon de keys van de hi­d­den-ser­vi­ces op­slaat, uit­rus­ten met ex­ter­ne vo­lu­mes. Je kunt daar twee Doc­ker-vo­lu­mes voor con­fi­gu­re­ren of het

be­stand /da­ta/my­tor/tor­rc en de di­rec­to­ry /da­ta/my­tor/da­ta ge­brui­ken:

doc­ker run --na­me my­tor \ -v /da­ta/my­tor/tor­rc:/etc/tor/tor­rc \ -v /da­ta/my­tor/da­ta:/var/lib/tor tor

Daar­mee wordt de con­tai­ner my­tor ge­start.

Pro­gram­ma­con­tai­ner

Maar je kunt niet al­leen dae­mons in con­tai­ners stop­pen. Met een truc werkt het zelfs met pro­gram­ma's met een ge­brui­kers­in­ter­fa­ce. Als voor­beeld dient hier Bit­mes­sa­ge, een peer-to-peer-mes­sa­ging-sys­teem dat lijkt op e-mail en in het al­ge­meen ver­sleu­teld com­mu­ni­ceert. Het Py­thon-pro­gram­ma met gra­fi­sche in­ter­fa­ce moet om vei­lig­heids­re­de­nen ook in een con­tai­ner draai­en.

De clou is het pro­gram­ma met SSH en met ge­ac­ti­veer­de X-for­war­ding te star­ten. In de con­tai­ner hoeft dan geen ex­tra Xser­ver meer te draai­en, maar door de af­han­ke­lijk­he­den moet die wel ge­ïn­stal­leerd wor­den. Je ont­wik­kelt een ei­gen con­tai­ner op een ver­ge­lijk­ba­re ma­nier als bij Tor: start met een be­ken­de ba­sis­ima­ge, bij­voor­beeld De­bi­an Stretch, en een shell. De bij­be­ho­ren­de Doc­ker­fi­le ziet als volgt uit:

FROM de­bi­an:stretch CMD /bin/bash

Maak daar­uit een ima­ge en start de con­tai­ner:

doc­ker build -t bit­mes­sa­ge ./ doc­ker run -it --rm bit­mes­sa­ge

De eer­ste stap­pen in de Bit­mes­sa­ge-con­tai­ner lij­ken op die je ook voor de Tor-con­tai­ner moet uit­voe­ren: down­load de pak­ket­lijs­ten, in­stal­leer al­le up­da­tes en daar­na ook nog de SSH-dae­mon:

apt-get up­da­te apt-get -y dist-up­gra­de apt-get -y in­stall ssh

Met de SSH-dae­mon, die je la­ter ook ge­bruikt om Bit­mes­sa­ge te star­ten, kun je via SSH al­le ove­ri­ge stap­pen in de draai­en­de con­tai­ner uit­voe­ren. Stan­daard werkt SSH ove­ri­gens op de ach­ter­grond, maar heb je een voor­grond­pro­ces als en­try­po­int no­dig. De SSH-ser­vi­ce in de con­tai­ner moet dus wor­den uit­ge­scha­keld. Je doet dat met sys­temctl disa­ble sshd.ser­vi­ce. Daar­naast heeft sshd de di­rec­to­ry /var/run/sshd no­dig en moet je het voor de root tij­de­lijk mo­ge­lijk ma­ken om via SSH in te log­gen om te kun­nen con­fi­gu­re­ren. Je kunt de be­tref­fen­de re­gels al­le­maal aan de Doc­ker­fi­le toe­voe­gen:

FROM de­bi­an:stretch

RUN apt-get up­da­te && \ apt-get -y dist-up­gra­de && \ apt-get -y in­stall ssh

RUN mk­dir -p /var/run/sshd

RUN sys­temctl disa­ble sshd.ser­vi­ce EN­TRY­PO­INT ["/usr/sbin/sshd","-o", "Per­mitRootLo­gin yes","-D"]

Con­fi­gu­re­ren via SSH

Als je de ima­ge met doc­ker build op­nieuw ge­maakt hebt, kun je de con­tai­ner star­ten. Om te kun­nen in­log­gen, moet je nog je open­ba­re sleu­tel aan de con­tai­ner kop­pe­len als /root/.ssh/au­tho­ri­ze­d_­keys. Het com­man­do daar­voor ziet er als volgt uit:

doc­ker run --na­me my­bit­mes­sa­ge \ -v $HO­ME/.ssh/id_r­sa.pub:\ /root/.ssh/au­tho­ri­ze­d_­keys \ -d bit­mes­sa­ge

Met doc­ker net­work in­spect ach­ter­haal je het ip-adres van de Bit­mes­sa­ge-con­tai­ner. Log in via SSH en con­fi­gu­reer Bit­mes­sa­ge. In de in­stal­la­tie­hand­lei­ding van github. com staan en­ke­le aan­kno­pings­pun­ten, voor de rest geldt sim­pel­weg het prin­ci­pe van tri­al-and-er­ror.

Be­lang­rijk is daar­bij dat Bit­mes­sa­ge la­ter geen root­rech­ten meer mag heb­ben, wat ook he­le­maal niet no­dig is. Maak daar­om met­een een ei­gen ge­brui­ker aan:

use­radd -c "Bit­Mes­sa­ge" \ -d /ho­me/bit­mes­sa­ge -m \ -s /ho­me/bit­mes­sa­ge/py­bit­mes­sa­ge \ -u 999 bit­mes­sa­ge Om tel­kens de nieuw­ste ver­sie van Bit­mes­sa­ge te ge­brui­ken, kun je be­ter met­een de soft­wa­re op GitHub ge­brui­ken en het pro­gram­ma zelf com­pi­le­ren. Daar heb je wel en­ke­le ont­wik­kel­pak­ket­ten uit de re­po­si­to­ry van De­bi­an voor no­dig:

apt-get -y in­stall build-es­sen­ti­al \ libs­sl-dev git opens­sl py­thon \ py­thon-ms­g­pack py­thon-qt4 sq­li­te3

Met het on­der­staan­de wordt Bit­mes­sa­ge ge­com­pi­leerd en wordt de ho­me-di­rec­to­ry voor­be­reid op de con­fi­gu­ra­tie­be­stan­den van het pro­gram­ma:

git clo­ne https://github.com/— Bit­mes­sa­ge/Py­Bit­mes­sa­ge \ /ho­me/bit­mes­sa­ge/Py­Bit­mes­sa­ge ma­ke -C /ho­me/bit­mes­sa­ge/Py­Bit­mes­sa­ge—

/src/bit­ms­g­hash mk­dir -p /ho­me/bit­mes­sa­ge/.ssh \ /ho­me/bit­mes­sa­ge/.con­fig/Py­Bit­mes­sa­ge chown -R bit­mes­sa­ge:bit­mes­sa­ge \

/ho­me/bit­mes­sa­ge

De lo­gin-shell van ge­brui­ker bit­mes­sa­ge is het shellscript /ho­me/bit­mes­sa­ge/py­bit­mes­sa­ge. Voeg aan dat script nog de vol­gen­de in­houd toe en maak het script uit­voer­baar:

#!/bin/sh

/usr/bin/py­thon /ho­me/bit­mes­sa­ge/— Py­Bit­mes­sa­ge/src/bit­mes­sa­ge­main.py

Daar­mee heb je Bit­mes­sa­ge he­le­maal ge­con­fi­gu­reerd en kun je de af­zon­der­lij­ke stap­pen in de Doc­ker­fi­le zet­ten. Het vol­le­di­ge be­stand staat rechts­on­der op de vo­ri­ge pa­gi­na. Dat be­vat ook en­ke­le in­struc­ties om ont­wik­kel­pak­ket­ten die je na het con­fi­gu­re­ren niet meer no­dig hebt

te ver­wij­de­ren. Daar­mee blijft het con­tai­ner­be­stand klein.

Na­dat je de con­tai­ner op­nieuw hebt ge­maakt, start je hem als volgt:

su­do doc­ker run --na­me my­bit­mes­sa­ge \ -v $HO­ME/.ssh/id_r­sa.pub:\ /root/.ssh/au­tho­ri­ze­d_­keys \ -v my­bit­mes­sa­ge:/ho­me/bit­mes­sa­ge/— .con­fig/Py­Bit­mes­sa­ge \

-d bit­mes­sa­ge

Daar­mee ko­men de con­fi­gu­ra­tie voor Bit­mes­sa­ge, de sleu­tels en de be­rich­ten in het Doc­ker-vo­lu­me my­bit­mes­sa­ge te staan.

Ver­bon­den con­tai­ners

Om er­voor te zor­gen dat Bit­mes­sa­ge ook be­rich­ten uit het darknet kan ont­van­gen en Bit­mes­sa­ge-no­des uit het darknet kan be­rei­ken, kun je hem com­bi­ne­ren met de eer­der ge­maak­te Tor-con­tai­ner. Bit­mes­sa­ge wordt dan zo­da­nig via de in­stel­lin­gen ge­con­fi­gu­reerd dat poort 9050 van Tor als SOCKS5-proxy ge­bruikt wordt – daar moet je dan wel het ip-adres van de Tor-con­tai­ner voor we­ten. Daar­om is het han­di­ger om Tor en Bit­mes­sa­ge in een ei­gen User De­fi­ned Net­work op te ne­men (zo­als be­schre­ven in het ar­ti­kel op pa­gi­na 122) en aan die fea­tu­res een vast ip-adres toe te ken­nen. De start­com­man­do's wor­den daar­door wel aan­zien­lijk lan­ger:

su­do doc­ker net­work cre­a­te \

--sub­net 172.20.0.0/16 \

--ga­te­way 172.20.0.1 darknet su­do doc­ker run --na­me my­tor \ --net­work darknet --ip 172.20.0.2 \ -v /da­ta/my­tor/tor­rc::

./etc/tor/tor­rc \ -v /da­ta/my­tor/da­ta:/var/lib/tor tor su­do doc­ker run --na­me my­bit­mes­sa­ge \ --net­work darknet --ip 172.20.0.3 \ -v $HO­ME/.ssh/id_r­sa.pub:\ /root/.ssh/au­tho­ri­ze­d_­keys \ -v my­bit­mes­sa­ge:/ho­me/bit­mes­sa­ge/— .con­fig/Py­Bit­mes­sa­ge \

-d bit­mes­sa­ge

Daar zul­len wei­nig men­sen op zit­ten te wach­ten. Sa­men­han­gen­de con­tai­ners kun je daar­om be­ter be­he­ren met Doc­ker Com­po­se – te vin­den als bi­nair pro­gram­ma in de Doc­ker-GitHub. Er­van uit­gaan­de dat je de Doc­ker­fi­le voor Tor in de sub­map tor en die voor Bit­mes­sa­ge in de sub­map bit­mes­sa­ge hebt staan, maak je in de map er­bo­ven het be­stand doc­ker­com­po­se.yml aan. Daar­in moet al­le in­for­ma­tie ko­men te staan die voor het ma­ken en star­ten van de con­tai­ners no­dig is. In het ka­der hier­on­der staat de in­houd van het Doc­ker Com­po­se-be­stand voor Bit­mes­sa­ge met Tor.

Een YML-be­stand be­gint al­tijd met het ver­mel­den van het ver­sie­num­mer – het voor­beeld ge­bruikt ver­sie 2 die sinds Com­po­se-ver­sie 1.10.0 on­der­steund wordt. Daar­na volgt het con­fi­gu­re­ren van de net­wer­ken voor de con­tai­ners. Voor de ser­vi­ces is er een apar­te ge­lijk­na­mi­ge 'ru­briek' ser­vi­ces. Daar­in staat on­der meer ook de net­werk­con­fi­gu­ra­tie van darknet en wordt de op­start­volg­or­de van de con­tai­ners be­paald. Daar­bij wordt de Tor-con­tai­ner als af­han­ke­lijk­heid van de Bit­mes­sa­ge-con­tai­ner aan­ge­ge­ven. Je kunt de eer­ste ge­com­bi­neer­de start het bes­te op de voor­grond uit­voe­ren:

su­do doc­ker-com­po­se up

Daar­mee zie je even­tu­e­le fout­mel­din­gen met­een op de con­so­le ver­schij­nen. Met Ctrl+C stop je de con­tai­ners weer. Met de pa­ra­me­ter -d aan het eind start je de con­tai­ners op de ach­ter­grond. Dat geldt ove­ri­gens niet al­leen voor je ei­gen com­pu­ter: als je de Doc­ker­fi­les, het Com­po­se-be­stand en de data­di­rec­to­ry's ko­pi­eert naar een wil­le­keu­ri­ge an­de­re com­pu­ter en daar ook Doc­ker en Doc­ker Com­po­se in­stal­leert, ben je met doc­ker-com­po­se up bin­nen en­ke­le se­con­den on­li­ne. (mvdm)

De Doc­ker­fi­le voor tor ge­bruikt Al­pi­ne Li­nux als ba­sis­ima­ge.

De Doc­ker­fi­le voor Bit­mes­sa­ge: het pro­gram­ma wordt ge­start via SSH met X-por­for­war­ding.

Zelfs pro­gram­ma's met een GUI, hier de peer2peer-mes­sen­ger Bit­mes­sa­ge, kun­nen in een con­tai­ner wer­ken.

In het Doc­ker Com­po­se-be­stand staat al­le in­for­ma­tie voor het ma­ken en star­ten van ver­bon­den con­tai­ners. Daar­mee wordt het op­star­ten een stuk mak­ke­lij­ker.

Newspapers in Dutch

Newspapers from Netherlands

© PressReader. All rights reserved.