Spring Boot 4-mikrotjänster och REST API:er · Lektion

Dockerisera Spring Boot-applikationer

Skapa Dockerfiles för att paketera Era Spring Boot-applikationer i lätta, portabla containrar.

Lektion 1 av 312 steg

Dockerisera Spring Boot-applikationer är en gratis lektion i Spring Boot 4-mikrotjänster och REST API:er på CoddyKit. Detta är lektion 1 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Spring Boot 4-mikrotjänster och REST API:er, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Spring Boot 4-mikrotjänster och REST API:er innehåller totalt 3 lektioner.

Varför containerisera Spring Boot?

Välkommen till containerisering av Spring Boot-appar! Docker hjälper dig att paketera din applikation i en standardiserad enhet som kallas en container.

Varför är detta bra för Spring Boot?

Portabilitet: Kör din app konsekvent överallt där Docker körs.
Isolering: Din app och dess beroenden paketeras tillsammans, vilket undviker konflikter.
Konsekvens: Miljön är densamma från utveckling till produktion.

Docker-grunder för appar

Innan vi börjar går vi snabbt igenom viktiga Docker-termer:

Avbild: Ett lättviktigt, fristående och körbart paket som innehåller allt som behövs för att köra en programvarudel, inklusive kod, runtime, bibliotek, miljövariabler och konfigurationsfiler. Se det som en ritning.
Container: En körbar instans av en avbild. Du kan skapa, starta, stoppa, flytta eller ta bort en container. Det är den faktiskt körande applikationen.
Dockerfile: En textfil som innehåller alla kommandon, i rätt ordning, för att bygga en viss avbild.

Vår exempelapp med Spring Boot

Föreställ dig att vi har en enkel Spring Boot-applikation. När vi bygger den skapas vanligtvis en enda körbar JAR-fil (till exempel my-app.jar).

Här är en grundläggande struktur för en Spring Boot-applikation:

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!");
  }
}

Introduktion till Dockerfile

En Dockerfile är ett skript med instruktioner som Docker använder för att bygga en avbild. Den fungerar som ett recept för att skapa din containermiljö.

Vi skapar en fil med namnet Dockerfile (utan filändelse) i rotkatalogen för vårt Spring Boot-projekt. Varje rad i Dockerfile-filen är en instruktion.

Välja en basavbild (FROM)

Varje Dockerfile börjar med instruktionen FROM. Den anger vilken basavbild din applikation ska bygga vidare på. För Java-applikationer är en OpenJDK-avbild ett vanligt val.

openjdk:17-jdk-slim tillhandahåller ett Java 17 Development Kit (JDK) i en slimmad, mindre avbild, vilket passar bra för produktion.

FROM openjdk:17-jdk-slim

Kopiera din applikation (COPY)

Nästa steg är att få in vår kompilerade Spring Boot-JAR-fil i Docker-avbilden. Instruktionen COPY gör precis det.

Om din byggda JAR-fil finns i target/my-app.jar kopierar vi den till avbildens rotkatalog och döper om den till app.jar för enkelhetens skull.

COPY target/my-app.jar app.jar

Exponera portar (EXPOSE)

Spring Boot-applikationer körs vanligtvis på en specifik port, ofta 8080. Instruktionen EXPOSE informerar Docker om att containern lyssnar på de angivna nätverksportarna under körning.

EXPOSE publicerar inte porten i praktiken, men fungerar som dokumentation och underlättar portmappning när containern körs.

EXPOSE 8080

Definiera startpunkten (ENTRYPOINT)

Instruktionen ENTRYPOINT konfigurerar en container som ska köras som en körbar fil. På så sätt anger vi för Docker att Spring Boot-applikationen ska startas när containern startar.

Vi använder kommandot java -jar app.jar för att köra applikationens JAR-fil.

ENTRYPOINT ["java", "-jar", "app.jar"]

Sätta ihop allt: Dockerfile

Så här ser vår fullständiga Dockerfile ut. Du placerar den här filen i rotkatalogen för ditt Spring Boot-projekt.

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"]

Obs! JAR-filens namn kan variera beroende på projektet. VOLUME /tmp läggs ofta till för att stödja Spring Boots inbäddade Tomcat.

Bygga din Docker-avbild

När din Dockerfile är klar och Spring Boot-applikationen är kompilerad (till exempel med mvn package) kan du bygga Docker-avbilden.

Gå till projektets rotkatalog i terminalen och kör:

docker build -t my-spring-app .

Det här kommandot:

docker build: Startar processen för att bygga avbilden.
-t my-spring-app: Märker avbilden med ett namn (my-spring-app).
.: Anger byggkontexten (den aktuella katalogen där Dockerfile-filen finns).

Kontroll av Dockerfile-instruktioner

Vilken Dockerfile-instruktion används för att definiera kommandot som körs när en container startas från en avbild?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Containerisera din app

Du har nu lärt dig grunderna i att containerisera en Spring Boot-applikation!

Vi har förstått vilken roll Dockerfiles, avbilder och containers har.
Vi gick igenom viktiga Dockerfile-instruktioner: FROM, COPY, EXPOSE och ENTRYPOINT.
Nu vet du hur du paketerar din Spring Boot-JAR i en portabel Docker-avbild.

Detta lägger grunden för att köra dina applikationer konsekvent i alla Docker-miljöer!

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 24
Lektioner: 93

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Dockerisera Spring Boot-applikationer” gratis?

Ja – hela texten till ”Dockerisera Spring Boot-applikationer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Spring Boot 4-mikrotjänster och REST API:er, kan Ni uppgradera till CoddyKit PRO. Kursen i Spring Boot 4-mikrotjänster och REST API:er innehåller totalt 3 lektioner.

Vad lär jag mig i ”Dockerisera Spring Boot-applikationer”?

Skapa Dockerfiles för att paketera Era Spring Boot-applikationer i lätta, portabla containrar. Ni övar på Spring Boot 4-mikrotjänster och REST API:er med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Spring Boot 4-mikrotjänster och REST API:er?

Du behöver inga förkunskaper. Utbildningen i Spring Boot 4-mikrotjänster och REST API:er på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 3.

Hur lång tid tar lektionen ”Dockerisera Spring Boot-applikationer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Spring Boot 4-mikrotjänster och REST API:er-lektionen?

Ja. Varje Spring Boot 4-mikrotjänster och REST API:er-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Spring Boot 4-mikrotjänster och REST API:er