PricingLoginStart free
Spring Boot 4-mikrotjenester og REST API-er · leksjon

Konteinere Spring Boot-applikasjoner med Docker

Opprett Dockerfiles for å pakke Spring Boot-applikasjonene dine i lette og portable konteinere.

Leksjon 1 av 312 trinn

Konteinere Spring Boot-applikasjoner med Docker er en gratis leksjon i Spring Boot 4-mikrotjenester og REST API-er på CoddyKit. Dette er leksjon 1 av 3. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Spring Boot 4-mikrotjenester og REST API-er, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Spring Boot 4-mikrotjenester og REST API-er inneholder totalt 3 leksjoner.

Hvorfor bruke Docker for Spring Boot?

Velkommen til en leksjon om å kjøre Spring Boot-apper i containere! Docker pakker applikasjonen inn i en standardisert enhet kalt en container.

Hvorfor er dette nyttig for Spring Boot?

  • Portabilitet: Kjør appen konsekvent overalt der Docker kjører.
  • Isolasjon: Appen og avhengighetene pakkes sammen, slik at konflikter unngås.
  • Konsistens: Miljøet er det samme fra utvikling til produksjon.

Docker-grunnleggende for apper

Før vi går videre, skal vi raskt definere noen viktige Docker-begreper:

  • Image: En lett, frittstående og kjørbar pakke som inneholder alt som trengs for å kjøre en del programvare, inkludert kode, kjøremiljø, biblioteker, miljøvariabler og konfigurasjonsfiler. Tenk på det som en mal.
  • Container: En kjørbar instans av et image. De kan opprette, starte, stoppe, flytte eller slette en container. Det er selve applikasjonen som kjører.
  • Dockerfile: En tekstfil som inneholder alle kommandoene, i riktig rekkefølge, for å bygge et bestemt image.

Eksempel på en Spring Boot-app

La oss tenke oss at vi har en enkel Spring Boot-applikasjon. Når vi bygger den, produserer den vanligvis én kjørbar JAR-fil (for eksempel my-app.jar).

Her er en grunnleggende struktur for en Spring Boot-applikasjon:

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

Introduksjon til Dockerfile

En Dockerfile er et instruksjonsskript som Docker bruker til å bygge et image. Den fungerer som en oppskrift for å opprette containermiljøet.

Vi oppretter en fil med navnet Dockerfile (uten filendelse) i rotmappen til Spring Boot-prosjektet. Hver linje i Dockerfile er en instruksjon.

Velge et baseimage (FROM)

Alle Dockerfile-filer starter med instruksjonen FROM. Den angir hvilket baseimage applikasjonen skal bygges på. For Java-applikasjoner er et OpenJDK-image et vanlig valg.

openjdk:17-jdk-slim inneholder et Java 17 Development Kit (JDK) i et slankt og mindre image, noe som passer godt til produksjon.

FROM openjdk:17-jdk-slim

Kopiere applikasjonen (COPY)

Deretter må vi få den kompilerte Spring Boot-JAR-filen inn i Docker-imaget. Instruksjonen COPY gjør nettopp dette.

Hvis den bygde JAR-filen ligger i target/my-app.jar, kopierer vi den til rotmappen i imaget og gir den navnet app.jar for enkelhets skyld.

COPY target/my-app.jar app.jar

Eksponere porter (EXPOSE)

Spring Boot-applikasjoner kjører vanligvis på en bestemt port, ofte 8080. Instruksjonen EXPOSE informerer Docker om at containeren lytter på de angitte nettverksportene under kjøring.

Selv om EXPOSE ikke faktisk publiserer porten, fungerer den som dokumentasjon og gjør porttilordning enklere når containeren kjøres.

EXPOSE 8080

Definere inngangspunktet (ENTRYPOINT)

Instruksjonen ENTRYPOINT konfigurerer en container som skal kjøre som en kjørbar enhet. Slik forteller vi Docker at Spring Boot-applikasjonen skal startes når containeren starter.

Vi bruker kommandoen java -jar app.jar til å kjøre applikasjonens JAR-fil.

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

Sette alt sammen: Dockerfile

Slik ser den komplette Dockerfile-filen vår ut. De plasserer denne filen i rotmappen til Spring Boot-prosjektet.

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

Merk: JAR-navnet kan variere avhengig av prosjektet. VOLUME /tmp legges ofte til for å støtte Spring Boots innebygde Tomcat.

Bygge Docker-imaget

Når Dockerfile-filen er klar og Spring Boot-applikasjonen er kompilert (for eksempel med mvn package), kan De bygge Docker-imaget.

Gå til prosjektets rotmappe i terminalen og kjør:

docker build -t my-spring-app .

Denne kommandoen:

  • docker build: Starter prosessen med å bygge imaget.
  • -t my-spring-app: Merker imaget med et navn (my-spring-app).
  • .: Angir byggkonteksten (den gjeldende mappen, der Dockerfile ligger).

Kontroll av Dockerfile-instruksjoner

Hvilken Dockerfile-instruksjon brukes til å definere kommandoen som kjøres når en container startes fra et image?

Besvar den i den interaktive leksjonen

Oppsummering: Gjøre appen til en Docker-container

De har nå lært det grunnleggende om å gjøre en Spring Boot-applikasjon til en Docker-container!

  • Vi har forstått rollen til Dockerfile-filer, images og containere.
  • Vi har utforsket viktige Dockerfile-instruksjoner: FROM, COPY, EXPOSE og ENTRYPOINT.
  • De vet nå hvordan De pakker Spring Boot-JAR-filen inn i et portabelt Docker-image.

Dette danner grunnlaget for å kjøre applikasjonene konsekvent i alle Docker-miljøer!

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
24
Leksjoner
93
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Konteinere Spring Boot-applikasjoner med Docker» gratis?

Ja – hele teksten i «Konteinere Spring Boot-applikasjoner med Docker» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Spring Boot 4-mikrotjenester og REST API-er-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Spring Boot 4-mikrotjenester og REST API-er inneholder totalt 3 leksjoner.

Hva lærer jeg i «Konteinere Spring Boot-applikasjoner med Docker»?

Opprett Dockerfiles for å pakke Spring Boot-applikasjonene dine i lette og portable konteinere. Du øver på Spring Boot 4-mikrotjenester og REST API-er med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Spring Boot 4-mikrotjenester og REST API-er?

Ingen tidligere erfaring er nødvendig. Spring Boot 4-mikrotjenester og REST API-er på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 3.

Hvor lang tid tar leksjonen «Konteinere Spring Boot-applikasjoner med Docker»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Spring Boot 4-mikrotjenester og REST API-er-leksjonen?

Ja. Alle Spring Boot 4-mikrotjenester og REST API-er-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Konteinere Spring Boot-applikasjoner med Docker
  2. Administrere konteinere med Docker Compose
  3. Begreper innen konteinerorkestrering
← Tilbake til Spring Boot 4-mikrotjenester og REST API-er