Hoe Docker-containers op externe servers te implementeren

Werken met Docker-containers op externe servers Het is de basis geworden voor iedereen die moderne applicaties wil implementeren zonder vast te lopen in afhankelijkheden, bibliotheekversies en de klassieke "het werkt op mijn machine". Echter, wanneer we overstappen van het uitvoeren van een eenvoudige applicatie naar een meer geavanceerde implementatie, dan verandert dat. docker run Als je begint met het opzetten van een serieuze implementatie lokaal op een Linux-server, met Docker Compose, GitHub-shares, Plesk, Portainer of zelfs grafische applicaties die toegankelijk zijn via een browser, dan wordt het al snel een stuk ingewikkelder.

Als het uw doel is om Docker-containers op een externe server te implementeren, is dat een goede optie. (Ubuntu, Debian, Windows met WSL 2, een cloudserver, Plesk, enz.) en dat op een onderhoudbare, geautomatiseerde en veilige manier. Deze handleiding biedt een vrij compleet overzicht: van het basisgebruik van Docker Compose op afstand, tot ontwikkelomgevingen met VS Code, implementaties vanuit Plesk, beheer met Portainer en het op afstand uitvoeren van grafische applicaties met noVNC en Caddy.

Basisconcepten: Docker-containers en implementatie op afstand

Docker is een containerplatform. Het verpakt een applicatie samen met alles wat nodig is (bibliotheken, afhankelijkheden, binaire bestanden, minimale systeemconfiguratie) zodat deze op elke machine met de Docker-engine geïnstalleerd hetzelfde werkt. Het belangrijkste verschil met een virtuele machine is dat de container geen volledig besturingssysteem bevat; in plaats daarvan deelt hij de kernel van de host, wat resulteert in lichtere images en betere prestaties.

Docker-containers implementeren op externe servers. Doorgaans heb je een host (bijvoorbeeld een Ubuntu-server in de cloud) met Docker en, optioneel, Docker Compose, en stuur je de code of images ernaartoe om ze uit te voeren. Je kunt dit handmatig doen via SSH, automatiseren met GitHub Actions, of integreren met dashboards zoals Plesk of tools zoals Portainer.

De belangrijkste praktijksituaties die je zult tegenkomen Als je het hebt over "remote Docker", dan zijn er drie aspecten: lokale ontwikkeling waarbij containers op een andere machine (of in WSL 2) draaien, geautomatiseerde implementatie van backend-/frontendservices en beheer van productiecontainers (monitoring, logging, herstarten, netwerkbeleid, enz.). De technologie is hetzelfde; wat verandert, is de manier waarop het wordt georkestreerd.

Naast traditionele backend-servicesDocker biedt een minder bekende, maar zeer krachtige mogelijkheid: het uitvoeren van grafische applicaties (e-mailclients, IDE's, analysetools, enz.) in externe containers en deze vervolgens via VNC over WebSocket vanuit een browser benaderen. Het is een handige manier om krachtige servers te gebruiken wanneer uw pc zelf niet krachtig genoeg is.

Van `docker run` naar Docker Compose op een externe server.

Een vrij gangbaar patroon van handmatige implementatie Het bestaat uit een code-repository op GitHub, een externe Ubuntu-server met Docker geïnstalleerd, en een CI/CD-workflow (bijvoorbeeld GitHub Actions) die het volgende doet wanneer je naar een branch pusht, zoals development o main:

• Maak via SSH verbinding met de externe server.
• Stop en verwijder de draaiende containers.
• Download de nieuwe images van Docker Hub (of van je eigen privéregister).
• lopen docker run voor elke dienst.
• Laat Nginx (of de reverse proxy die je gebruikt) het verkeer doorsturen naar de poorten van elke container.

Wanneer je overschakelt naar Docker Compose Het proces wordt aanzienlijk vereenvoudigd, omdat je in plaats van containers één voor één te beheren, je volledige stack (frontend, backend, database, cache, enz.) in één keer definieert. docker-compose.yml, met zijn netwerken, volumes en omgevingsvariabelen.

De eenvoudigste (en vrij gangbare) werkwijze met GitHub Actions De workflow moet het volgende uitvoeren: cd naar de projectmap op de externe server (waar uw docker-compose.yml) en commando's uitvoeren zoals:

• docker compose pull om de meest recente beelden te tonen.
• docker compose down om oude containers te stoppen en te verwijderen (eventueel met --remove-orphans).
• docker compose up -d --build als je de afbeeldingen rechtstreeks vanaf de server genereert.

Deze aanpak werkt goed en is behoorlijk robuust.Mits je goede controle hebt over inloggegevens, omgevingsvariabelen en volumes, kun je de beveiliging verbeteren door te voorkomen dat GitHub Actions volledige roottoegang tot de server krijgt, SSH-sleutels te beperken, speciale gebruikers te gebruiken of zelfs Docker als een beveiligde externe service met certificaten beschikbaar te stellen in plaats van alles via SSH uit te voeren.

Er bestaat geen betere "magische manier" dan deze. Voor een eenvoudige omgeving: de sleutel is automatisering en goede code. docker-compose.ymlGebruik onveranderlijke afbeeldingstags (bijv. specifieke versies) en zorg voor een terugdraaimechanisme (bijv. het opslaan van de vorige versie van de compositie of de afbeeldingen).

Ontwikkelomgeving op afstand met Docker, WSL 2 en VS Code.

Op Windows is het heel gebruikelijk om met Docker te ontwikkelen via WSL 2.Docker Desktop voor Windows biedt een op WSL 2 gebaseerde engine waarmee je Linux- en Windows-containers vanaf dezelfde machine kunt uitvoeren, terwijl je code bewerkt met VS Code en test in de lokale browser.

De gebruikelijke workflow voor het opzetten van een ontwikkelomgeving met externe containers met behulp van WSL 2. hij is zeker:

1. Installeer WSL 2 en een Linux-distributie (bijvoorbeeld Ubuntu).
2. Je installeert Docker Desktop op Windows en schakelt de optie "Gebruik WSL 2-gebaseerde engine" in via Instellingen > Algemeen.
3. In Instellingen > Bronnen > WSL-integratie selecteert u de WSL-distributies waarop u Docker wilt laten werken.
4. Je controleert de installatie met docker --version en rennen docker run hello-world binnen de WSL-distributie.

Om te ontwikkelen “binnen” de containers Het gaat niet alleen om het gebruik van Docker als engine; VS Code is essentieel. Met de WSL-, Dev Containers- en Docker-extensies kun je bijvoorbeeld het volgende doen:

• Open je projectmap die in WSL wordt gehost rechtstreeks in VS Code.
• Heropen die map “in een ontwikkelomgeving” (Dev Container), met behulp van een Dockerfile en een devcontainer.json die uw ideale omgeving beschrijven (Python-versie, Node, enz.).
• Debug je applicatie vanuit VS Code terwijl deze in de container draait.

Een heel bekend voorbeeld Het werkt met een Django- of Node.js-project: je kloont de repository in WSL, opent de map met code .Je selecteert een definitie voor de ontwikkelcontainer (bijvoorbeeld "Python 3") en VS Code bouwt de image en start de container met alle benodigde afhankelijkheden. Vervolgens kun je de code uitvoeren, debuggen en controleren of deze werkt op Linux, zelfs als je hostsysteem Windows is.

Deze aanpak is ook handig als je computer niet erg krachtig is.Omdat je met Docker een deel van de belasting naar een externe server kunt verplaatsen en er vervolgens via SSH en Dev Containers verbinding mee kunt maken met VS Code, werkt het bijna alsof het lokaal is, maar dan wel afhankelijk van de resources van de server.

Applicaties implementeren op een cloudserver met Docker en Docker Compose.

Een cloudserver met Docker klaarzetten voor implementatie. Bij de meeste providers gaat het heel snel: je kiest een systeemimage waarop Docker al is voorgeïnstalleerd, wacht een paar minuten en je machine is klaar om containers te ontvangen.

Een typisch patroon voor het implementeren van een eenvoudige Node.js-applicatie. Het zou dit zijn:

1. Maak het Node.js-project (bijvoorbeeld een "Hello world"-project met Express) aan op je lokale machine: projectmap, submap app, npm init, installatie van afhankelijkheden (zoals express) en een index.js Dat zet een server op poort 3030 op met een eenvoudig bericht.
2. Dockeriseer de app met een Dockerfile dat de basisafbeelding definieert (bijvoorbeeld node:12) The WORKDIRKopieer de app-bestanden en voer het programma uit. npm install en de interne poort blootleggen.
3. Voeg een ... toe .dockerignore om te voorkomen dat je dingen plaatst zoals node_modules.
4. Maak een havenarbeider-compose.yml in de projectmap, waarmee de versie wordt aangegeven (bijvoorbeeld, 3.8) en het definiëren van de belangrijkste dienst, de build, poorttoewijzing (3030:3030) en het commando (node index).

Zodra het project en de compositie klaar zijn,De implementatie naar de externe server verloopt doorgaans volgens dit proces:

• Je maakt via SSH verbinding met de server.
• Je kloont de repository of uploadt de bestanden (Git, SCP, rsync…).
• Jij installeert havenarbeider-compose als het er nog niet was (in veel distributies moet je het apart van Docker installeren, bijvoorbeeld door het binaire bestand van GitHub te downloaden en het uitvoerrechten te geven).
• Je voert uit docker-compose up (o docker compose up (afhankelijk van de versie) zodat de afbeeldingen worden gedownload, uw app-image wordt gebouwd en de containers worden gestart.

Een punt dat vaak over het hoofd wordt gezien, is de firewall van de leverancier.Als uw service luistert op poort 3030, moet u deze openen in uw firewallregels of een specifiek beleid aanmaken en dit aan de server koppelen. Anders krijgt u van buitenaf alleen een "verbinding geweigerd"-bericht te zien, zelfs als de container correct werkt.

Zodra het operationeel is, kunt u de applicatie gebruiken. gebruikmakend van het openbare IP-adres en de blootgestelde poort van de server (bijvoorbeeld, https://IP_DEL_SERVIDOR:3030), of door die poort te verbergen achter een reverse proxy zoals Nginx/Traefik die luistert op poort 80/443.

Externe containers beheren met Plesk en Docker.

Als u Plesk als uw controlepaneel gebruiktJe kunt ook gebruikmaken van de Docker-extensie om containers rechtstreeks vanuit de webinterface te beheren, zowel op de server zelf als op externe Docker-hosts.

Plesk ondersteunt Docker op een breed scala aan besturingssystemen.CentOS 7, RHEL 7, Debian 10/11/12, diverse versies van Ubuntu (18.04, 20.04, 22.04, 24.04), AlmaLinux 8/9, Rocky Linux 8.x en een bijgewerkte versie van Virtuozzo 7. In Plesk voor Windows draait Docker niet lokaal, maar op een externe machine die als Docker-host fungeert.

Er zijn enkele belangrijke beperkingen waarmee rekening moet worden gehouden.:

• Je kunt de Docker-extensie niet gebruiken als Plesk in een Docker-container is geïmplementeerd.
• Om Docker-services op afstand (d.w.z. externe hosts) te gebruiken, hebt u een extra licentie of specifieke pakketten nodig (Hosting Pack, Power Pack, Developer Pack).
• Docker-containers die door Plesk worden beheerd, zijn niet direct "migreerbaar", hoewel je de gegevens die ze gebruiken wel kunt back-uppen met behulp van volumes of snapshots.

Via de Plesk-interface kun je naar afbeeldingen zoeken. Zowel in de lokale repository (images die al naar de host zijn gedownload) als in Docker Hub. Om een ​​container te starten, begeleidt het paneel je:

1. Bezoeken Docker > Containers > Container uitvoeren.
2. Zoek de gewenste image en bekijk de bijbehorende documentatie op Docker Hub (indien van toepassing).
3. U kunt eventueel een specifiek label/versie voor de afbeelding selecteren.
4. Configureer de containerparameters (omgevingsvariabelen, poorten, volumes, geheugen, automatisch opstarten, enz.) en klik op Uitvoeren.

Plesk biedt je ook de mogelijkheid om geavanceerde instellingen te beheren. Voor elke container: wijs poorten opnieuw toe (automatisch of handmatig), bepaal of de poort toegankelijk is vanaf internet of alleen vanaf localhost, beperk het RAM-geheugen dat de container mag gebruiken, definieer volumes (pad op de host en in de container) of voeg zoveel omgevingsvariabelen toe als nodig is.

Wat betreft het aspect van orkestratie op afstandPlesk kan samenwerken met "externe Docker-services". Dit houdt in dat de Docker-daemon op de externe host geconfigureerd moet worden (bijvoorbeeld met behulp van een /etc/docker/daemon.json (met ondersteuning voor TLS- en TCP-sockets), certificaten genereren .pem en registreer die host in Plesk vanuit Docker > Omgevingen > Server toevoegenVervolgens kunt u dat Docker-knooppunt als actief markeren en via dezelfde interface schakelen tussen verschillende servers.

Docker Compose-stacks implementeren vanuit Plesk

Als je Docker Compose al gebruikt voor je infrastructuurWellicht bent u geïnteresseerd in de mogelijkheid om Plesk de implementatie van "stacks" vanuit bestanden te laten verzorgen. docker-compose.yml.

De workflow voor het implementeren van een Compose in Plesk Het is relatief eenvoudig:

1. Enter Docker > Stacks > Stack toevoegen.
2. Geef de stack een projectnaam.
3. Kies de bron voor het Compose-bestand: editor (plak de inhoud), upload een bestand vanaf uw computer of selecteer een bestaand bestand in de webruimte van een domein.
4. Bevestig de configuratie en laat Plesk de gedefinieerde containers aanmaken.

Alles wat tijdens het bouwproces wordt gebouwd. Het bijbehorende Compose-bestand wordt opgeslagen in de hoofdmap van de website, waardoor toegang tot logbestanden, tussentijdse resultaten en andere bestanden die tijdens de build zijn gegenereerd, eenvoudig is.

Plesk maakt ook het beheer van lokale afbeeldingen mogelijk.: van Docker > Afbeeldingen Je kunt filteren, verschillende productlabels bekijken, het gebruikte schijfgebruik inzien en verouderde afbeeldingen verwijderen om schijfruimte vrij te maken. Dit is belangrijk in externe omgevingen met beperkte opslagruimte.

Als je Nginx als je front-end webserver gebruiktPlesk past proxyregels toe (bijvoorbeeld in de nginx.conf (vanuit het domein) om verkeer naar uw Docker-containers te routeren, zelfs in scenario's achter NAT. Dit bespaart u de moeite van het handmatig configureren van reverse proxy's op externe servers.

Beheer containers op afstand met Portainer.

Portainer is een lichtgewicht webinterface. Voor Docker betekent dit een enorme vereenvoudiging van het dagelijkse werk voor degenen die niet constant met de commandoregel willen werken. Het functioneert zelf als een container en kan de lokale host of meerdere externe hosts beheren (zelfs met Portainer Agent).

Om Portainer op je server te installeren met behulp van Docker Je volgt doorgaans deze basisstappen:

• Maak een volume aan voor de Portainer-gegevens: docker volume create portainer_data.
• Start de Portainer-container door poorten 8000 en 9000 te mappen en de Docker-socket te mounten (/var/run/docker.sock) en het datavolume: docker run -d -p 8000:8000 -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer.

Hierdoor zal Portainer luisteren op poort 9000 van de server.Zoals altijd moet je de poort in je firewall openen of via een HTTPS-reverseproxy beschikbaar maken. De eerste keer dat je Portainer via een browser benadert, zal het programma je vragen een beheerdersaccount aan te maken. Daarna kun je kiezen of je de lokale Docker-container of extra externe hosts wilt beheren.

Het Portainer-paneel is zeer intuïtief.Je ziet actieve containers, hun logboeken, statistieken over resourceverbruik, Compose-stacks, netwerken, volumes en meer. En, het allerbelangrijkste: je kunt containers opnieuw aanmaken met andere parameters, images bijwerken, stacks beheren en meerdere externe servers centraliseren vanuit één interface.

Voer grafische applicaties uit in externe containers en open ze via een browser.

Wanneer uw computer geen resources meer heeft Maar als je zware grafische applicaties moet gebruiken (zoals e-mailclients, IDE's of reverse engineering-tools), is het een zeer interessante oplossing om ze in Docker-containers op een krachtige server te draaien en ze via het web te benaderen.

Een zeer goed gedocumenteerde casestudy. Het idee is om Mozilla Thunderbird in een container te verpakken, de grafische interface beschikbaar te maken via TigerVNC/noVNC en de toegang te beveiligen met Caddy. Dit concept kan worden hergebruikt voor vrijwel elke Linux GUI-applicatie.

De basisarchitectuur van dit type grafische container omvat doorgaans het volgende::

• Een lichtgewicht VNC/X11-server (TigerVNC) die als beeldschermserver fungeert.
• Een minimalistische vensterbeheerder (OpenBox) voor het beheren van vensters.
• Een klein, gebruiksvriendelijk servertype easy-novnc Dit maakt VNC beschikbaar als een WebSocket en genereert een HTML-pagina om vanuit de browser verbinding te maken.
• supervisord of iets soortgelijks om alle processen binnen de container te starten en te bewaken.
• De applicatie zelf (Thunderbird, GIMP, enz.) is geconfigureerd om op het externe scherm te worden weergegeven (DISPLAY=:0).

In de praktijk wordt een werkmap ingesteld. (bijvoorbeeld ~/thunderbird) waar ze geplaatst zijn:

• Un supervisord.conf Hierin worden de te starten programma's gedefinieerd: TigerVNC, easy-novnc, OpenBox en de hoofdapplicatie, met prioriteiten zodat de grafische server start vóór de applicatie.
• Un menu.xml OpenBox configureert het bureaubladmenu (hoofdapplicatie, terminal, procesmonitor met htop, enz.).
• Un Dockerfile met meerdere fasen die in de eerste fase compileert easy-novnc met Go, en in de tweede stap wordt de uiteindelijke image op Debian gemaakt, waarbij openbox, tigervnc, supervisor, console-hulpprogramma's en de applicatie (Thunderbird in het voorbeeld) worden geïnstalleerd, de binaire bestanden en configuraties worden gekopieerd, een niet-rootgebruiker wordt aangemaakt en een persistent datavolume wordt gedefinieerd. /data.

Het standaardcommando van de container wordt doorgaans gedelegeerd aan supervisord.door het op te starten zoals een normale gebruiker dat zou doen gosuNadat de machtigingen voor het datavolume zijn aangepast, worden VNC, noVNC, de windowmanager en de applicatie automatisch gestart wanneer de container opstart. U hoeft dan alleen nog maar toegang te krijgen tot de HTTP-poort die door easy-novnc beschikbaar wordt gesteld.

Om het robuuster en gebruiksvriendelijker te maken voor internet.Het is een goed idee om een ​​webserver zoals Caddy ervoor te plaatsen, ook in een container, die fungeert als een reverse proxy voor je grafische applicatie, basisauthenticatie toevoegt (gehashte gebruikersnaam en wachtwoord) en optioneel een WebDAV beschikbaar stelt voor toegang tot de bestanden. /data vanaf uw lokale computer.

Coördineer de oplossing met netwerken, volumes en Caddy.

Om dit type implementatie georganiseerd te houden De gebruikelijke aanpak is om je eigen Docker-netwerk en een of meer datavolumes te creëren:

• Netwerk, bijvoorbeeld. thunderbird-net, die gedeeld zal worden door alle gerelateerde containers.
• Volumen thunderbird-data die het gebruikersprofiel en de permanente gegevens van de grafische app zal bevatten.

De container van de grafische applicatie Je kunt het starten met zoiets als:

• politiek --restart=always zodat het op eigen benen kan staan.
• Volume-assemblage thunderbird-data:/data.
• Netwerkverbinding thunderbird-net.
• Herkenbare naam (thunderbird-app(bijvoorbeeld) die Caddy zal gebruiken voor de reverse proxy.

In een andere map (bijvoorbeeld, ~/caddy) het beeld van Caddy is geconstrueerd met de benodigde modules (zoals de WebDAV-plugin) en een Caddyfile die definieert:

• Een server op poort 8080.
• Un reverse_proxy naar thunderbird-app:8080 (of de poort die noVNC beschikbaar stelt).
• Extra paden voor het navigeren door bestanden (/files) en voor WebDAV (/webdav), die beide de inhoud van het datavolume weergeven.
• Een blok van basicauth Dit beveiligt alle paden met een gebruiker en een gehasht wachtwoord dat wordt gelezen uit omgevingsvariabelen.

Bij het aanmaken van de Caddy-containerhetzelfde volume wordt samengevoegd thunderbird-data:/dataHet maakt verbinding met het netwerk. thunderbird-net en de poort ervan is gepubliceerd (bijvoorbeeld, -p 8080:8080) op de host. Hiermee hoeft u alleen maar in uw browser te gaan naar http://IP_DEL_SERVIDOR:8080Voer uw inloggegevens in en klik op 'Verbinden' om de grafische applicatie op afstand te gaan gebruiken.

Langdurig onderhoud is eenvoudig.Wanneer je een update nodig hebt, kun je de containers stoppen en verwijderen, de images opnieuw opbouwen met de nieuwe versies en ze vervolgens opnieuw starten. docker run Het behouden van het datavolume, zodat de instellingen en bestanden van de gebruiker intact blijven.

Met al deze onderdelen (Docker Compose, Plesk, Portainer, VS Code, WSL 2, Caddy, noVNC…) Het is mogelijk om alles op te zetten, van eenvoudige backend-implementaties tot externe desktops die zijn ingekapseld in containers en perfect toegankelijk zijn via een browser. Hierbij wordt gebruikgemaakt van servers met veel meer rekenkracht dan uw eigen machine, terwijl u tegelijkertijd nauwkeurige controle behoudt over netwerken, beveiliging, opslag en updates.