Spring Boot-applicaties containeriseren met Docker
Maak Dockerfiles om uw Spring Boot-applicaties in lichte, draagbare containers te verpakken.
Spring Boot-applicaties containeriseren met Docker is een gratis Spring Boot 4-microservices en REST-API's-les op CoddyKit. Dit is les 1 van 3. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Spring Boot 4-microservices en REST-API's. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 3 lessen.
Waarom Spring Boot in Docker uitvoeren?
Welkom bij het containeriseren van Spring Boot-apps! Docker helpt je applicatie te verpakken in een gestandaardiseerde eenheid die een container wordt genoemd.
Waarom is dit zo handig voor Spring Boot?
- Overdraagbaarheid: Voer je app overal consistent uit waar Docker beschikbaar is.
- Isolatie: Je app en de afhankelijkheden ervan worden samen verpakt, waardoor conflicten worden voorkomen.
- Consistentie: De omgeving is hetzelfde vanaf ontwikkeling tot en met productie.
Docker-beginselen voor apps
Voordat we beginnen, definiëren we eerst kort enkele belangrijke Docker-termen:
- Image: Een lichtgewicht, zelfstandig en uitvoerbaar pakket dat alles bevat wat nodig is om een stuk software uit te voeren, waaronder de code, een runtime, bibliotheken, omgevingsvariabelen en configuratiebestanden. Zie het als een blauwdruk.
- Container: Een uitvoerbare instantie van een image. Je kunt een container maken, starten, stoppen, verplaatsen of verwijderen. Dit is de daadwerkelijk actieve applicatie.
- Dockerfile: Een tekstbestand met alle opdrachten, in de juiste volgorde, om een bepaald image te bouwen.
Onze voorbeeldapplicatie met Spring Boot
Laten we ons voorstellen dat we een eenvoudige Spring Boot-applicatie hebben. Wanneer we deze bouwen, levert dat meestal één uitvoerbaar JAR-bestand op (bijvoorbeeld my-app.jar).
Dit is een eenvoudige structuur van een Spring Boot-applicatie:
package com.coddykit.docker;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DockerApp {
public static void main(String[] args) {
SpringApplication.run(DockerApp.class, args);
// This will print to the container's standard output
System.out.println("Spring Boot app started inside Docker!");
}
}Kennismaken met de Dockerfile
Een Dockerfile is een script met instructies dat Docker gebruikt om een image te bouwen. Het is vergelijkbaar met een recept voor het maken van je containeromgeving.
We maken een bestand met de naam Dockerfile (zonder extensie) in de hoofdmap van ons Spring Boot-project. Elke regel in de Dockerfile is een instructie.
Een basisimage kiezen (FROM)
Elke Dockerfile begint met de instructie FROM. Hiermee geef je het basisimage aan waarop je applicatie wordt gebouwd. Voor Java-applicaties is een OpenJDK-image een veelgebruikte keuze.
openjdk:17-jdk-slim biedt een Java 17 Development Kit (JDK) in een slank, kleiner image, wat ideaal is voor productie.
FROM openjdk:17-jdk-slimJe applicatie kopiëren (COPY)
Vervolgens moeten we het gecompileerde Spring Boot-JAR-bestand in het Docker-image plaatsen. De instructie COPY doet precies dat.
Als je gebouwde JAR-bestand zich in target/my-app.jar bevindt, kopiëren we het naar de hoofdmap van het image en hernoemen we het voor de eenvoud naar app.jar.
COPY target/my-app.jar app.jarPoorten beschikbaar maken (EXPOSE)
Spring Boot-applicaties draaien meestal op een specifieke poort, vaak 8080. De instructie EXPOSE informeert Docker dat de container tijdens runtime op de opgegeven netwerkpoorten luistert.
Hoewel EXPOSE de poort niet daadwerkelijk publiceert, dient de instructie als documentatie en helpt deze bij het toewijzen van poorten wanneer je de container uitvoert.
EXPOSE 8080Het entrypoint definiëren (ENTRYPOINT)
De instructie ENTRYPOINT configureert een container die als uitvoerbaar bestand wordt uitgevoerd. Hiermee vertellen we Docker dat het onze Spring Boot-applicatie moet starten wanneer de container wordt gestart.
We gebruiken de opdracht java -jar app.jar om het JAR-bestand van onze applicatie uit te voeren.
ENTRYPOINT ["java", "-jar", "app.jar"]Alles samenbrengen: Dockerfile
Zo ziet onze volledige Dockerfile eruit. Je plaatst dit bestand in de hoofdmap van je Spring Boot-project.
FROM openjdk:17-jdk-slim
VOLUME /tmp
COPY target/docker-app-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]Opmerking: De naam van de JAR kan variëren afhankelijk van je project. VOLUME /tmp wordt vaak toegevoegd ter ondersteuning van de ingebouwde Tomcat van Spring Boot.
Je Docker-image bouwen
Zodra je Dockerfile klaar is en je Spring Boot-applicatie is gecompileerd (bijvoorbeeld met mvn package), kun je het Docker-image bouwen.
Ga in de terminal naar de hoofdmap van je project en voer het volgende uit:
docker build -t my-spring-app .Deze opdracht:
docker build: start het proces voor het bouwen van het image.-t my-spring-app: voorziet het image van een naam (tag) (my-spring-app)..: geeft de buildcontext aan (de huidige map, waarin de Dockerfile staat).
Controle van Dockerfile-instructies
Welke Dockerfile-instructie wordt gebruikt om de opdracht te definiëren die wordt uitgevoerd wanneer een container vanuit een image wordt gestart?
Samenvatting: je app in Docker uitvoeren
Je hebt de basisprincipes van het uitvoeren van een Spring Boot-applicatie in Docker succesvol geleerd!
- We hebben de rol van Dockerfiles, images en containers begrepen.
- We hebben belangrijke Dockerfile-instructies verkend:
FROM,COPY,EXPOSEenENTRYPOINT. - Je weet nu hoe je je Spring Boot-JAR in een overdraagbaar Docker-image bundelt.
Dit vormt de basis om je applicaties consistent in elke Docker-omgeving uit te voeren!
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 24
- Lessen
- 93
Veelgestelde vragen
Is de les “Spring Boot-applicaties containeriseren met Docker” gratis?
Ja — de volledige tekst van “Spring Boot-applicaties containeriseren met Docker” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Spring Boot 4-microservices en REST-API's wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 3 lessen.
Wat leer ik in “Spring Boot-applicaties containeriseren met Docker”?
Maak Dockerfiles om uw Spring Boot-applicaties in lichte, draagbare containers te verpakken. Je oefent met Spring Boot 4-microservices en REST-API's door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Spring Boot 4-microservices en REST-API's te beginnen?
Ervaring vooraf is niet nodig. Spring Boot 4-microservices en REST-API's op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.
Hoe lang duurt de les “Spring Boot-applicaties containeriseren met Docker”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Spring Boot 4-microservices en REST-API's?
Ja. Elke les over Spring Boot 4-microservices en REST-API's bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Spring Boot-applicaties containeriseren met Docker
- Containers beheren met Docker Compose
- Concepten van containerorkestratie