Kjører Spring Boot med PostgreSQL i Docker Compose
1. Introduksjon
I denne opplæringen ønsker vi å kjøre en Spring Boot-applikasjon med den populære open source-databasen PostgreSQL. I en tidligere artikkel, vi så på Docker Compose for å håndtere flere containere samtidig. Så i stedet for å installere PostgreSQL som et eget program, vi bruker Docker Compose til å kjøre Spring Boot og PostgreSQL.
2. Opprette Spring Boot Project
La oss gå til Spring Initializer og lage vårt Spring Boot-prosjekt. Vi legger til PostgreSQL Driver og Vårdata JPA moduler. Etter at vi har lastet ned den resulterende ZIP-filen og hentet den til en mappe, kan vi kjøre den nye applikasjonen:
./mvnw spring-boot: run
Søknaden mislykkes fordi den ikke kan koble til databasen:
*************************** SØKNAD KAN IKKE STARTE ****************** ******** Beskrivelse: Kunne ikke konfigurere en DataSource: 'url' attributt er ikke spesifisert, og ingen innebygd datakilde kan konfigureres. Årsak: Kunne ikke bestemme en passende førerklasse
3. Dockerfil
Før vi kan starte PostgreSQL med Docker Compose, vi trenger å gjøre vår Spring Boot-applikasjon til et Docker-bilde. Det første trinnet er å pakke applikasjonen som en JAR-fil:
./mvnw ren pakke -DskipTests
Her renser vi først opp våre tidligere bygninger før vi pakker applikasjonen. I tillegg hopper vi over testene fordi de mislykkes uten PostgreSQL.
Vi har nå en applikasjons-JAR-fil i mål katalog. Denne filen har prosjektnavnet og versjonsnummeret i navnet og ender med -SNAPSHOT.jar. Så navnet kan være docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar.
La oss lage det nye src / main / docker katalog. Etter det kopierer vi JAR-filen der:
cp target / docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar src / main / docker
Til slutt lager vi dette Dockerfil i den samme katalogen:
FRA adoptopenjdk: 11-jre-hotspot ARG JAR_FILE = *. Jar KOPIER $ {JAR_FILE} application.jar ENTRYPOINT ["java", "-jar", "application.jar"]
Denne filen beskriver hvordan Docker skal kjøre vår Spring Boot-applikasjon. Den bruker Java 11 fra AdoptOpenJDK og kopierer applikasjons-JAR-filen til application.jar. Den kjører deretter JAR-filen for å starte vår Spring Boot-applikasjon.
4. Docker komponere fil
La oss nå skrive vår Docker Compose-fil, docker-compose.yml, og lagre den på src / main / docker:
versjon: '2' tjenester: app: image: 'docker-spring-boot-postgres: latest' build: context:. container_name: app avhenger av: - db-miljø: - SPRING_DATASOURCE_URL = jdbc: postgresql: // db: 5432 / compose-postgres - SPRING_DATASOURCE_USERNAME = compose-postgres - SPRING_DATASOURCE_PASSWORD = compose-postgres_DATE_DATE: alpine 'container_name: db-miljø: - POSTGRES_USER = skriv-postgres - POSTGRES_PASSWORD = skriv-postgres
Søknaden vår heter app. Det er den første av to tjenester (linje 4-15):
- Spring Boot Docker-bildet har navnet docker-spring-boot-postgres: siste (linje 5). Docker bygger det bildet fra Dockerfil i den gjeldende katalogen (linje 6-7)
- Beholdernavnet er app (linje 8). Det kommer an på db tjeneste (linje 10). Derfor starter det etter db container
- Vår applikasjon bruker db PostgreSQL container som datakilde (linje 12). Databasenavnet, brukernavnet og passordet er alle komponere-postgres (linje 12-14)
- Dvalemodus oppretter eller oppdaterer automatisk alle databasetabeller som trengs (linje 15)
PostgreSQL-databasen har navnet db og er den andre tjenesten (linje 17-22):
- Vi bruker PostgreSQL 13.1 (linje 18)
- Beholdernavnet er db (linje 19)
- Brukernavnet og passordet er begge komponere-postgres (linje 21-22)
5. Kjører med Docker Compose
La oss kjøre vår Spring Boot-applikasjon og PostgreSQL med Docker Compose:
docker-komponere opp
For det første vil dette bygge Docker Image for Spring Boot-applikasjonen. Deretter starter den en PostgreSQL-container. Endelig vil den starte applikasjonen Docker image. Denne gangen går søknaden vår bra:
Starter DemoApplication v0.0.1-SNAPSHOT ved hjelp av Java 11.0.9 på f94e79a2c9fc med PID 1 (/application.jar startet av root i /) [...] Ferdig skanning av Spring Data repository på 28 ms. Fant 0 JPA repository grensesnitt. [...] Startet DemoApplication på 4,751 sekunder (JVM kjører i 6,512)
Som vi kan se, fant Spring Data ikke noe lagringsgrensesnitt. Det er riktig - vi opprettet ikke en enda!
Hvis vi vil stoppe alle containere, må vi først trykke på [Ctrl-C]. Da kan vi stoppe Docker Compose:
docker-komponer ned
6. Opprette en kundeenhet og et lager
For å bruke PostgreSQL-databasen i applikasjonen vår, vi oppretter en enkel kundeenhet:
@Entity @Table (name = "customer") offentlig klasse kunde {@Id @GeneratedValue privat lang id; @Column (name = "first_name", nullable = false) private String firstName; @Column (name = "last_name", nullable = false) private String etternavn;
De Kunde har en generert id attributt og to obligatoriske attributter: fornavn og etternavn.
Nå, vi kan skrive depotgrensesnittet for denne enheten:
offentlig grensesnitt CustomerRepository utvider JpaRepository {}
Ved ganske enkelt å utvide JpaRepository, arver vi metoder for å lage og spørre Kunde enhet.
Til slutt bruker vi disse metodene i applikasjonen vår:
@SpringBootApplication offentlig klasse DemoApplication {@Autowired private CustomerRepository repository; @EventListener (ApplicationReadyEvent.class) public void runAfterStartup () {List allCustomers = this.repository.findAll (); logger.info ("Antall kunder:" + allCustomers.size ()); Kunde newCustomer = ny kunde (); newCustomer.setFirstName ("John"); newCustomer.setLastName ("Doe"); logger.info ("Lagrer ny kunde ..."); this.repository.save (newCustomer); allCustomers = this.repository.findAll (); logger.info ("Antall kunder:" + allCustomers.size ()); }}
- Vi får tilgang til vårt Kunde depot gjennom avhengighetsinjeksjon
- Vi spør etter antall eksisterende kunder med depotet - dette vil være null
- Så oppretter og redder vi en kunde
- Når vi deretter spørrer om eksisterende kunder igjen, forventer vi å finne den vi nettopp opprettet
7. Kjører med Docker Compose Again
For å kjøre den oppdaterte Spring Boot-applikasjonen, må vi bygge den om først. Derfor utfører vi disse kommandoene en gang til i prosjektets rotkatalog:
./mvnw ren pakke -DskipTests cp target / docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar src / main / docker
Hvordan bygger vi Docker-bildet vårt på nytt med denne oppdaterte JAR-filen? Den beste måten er å fjerne det eksisterende Docker-bildet hvis navn vi spesifiserte i docker-compose.yml. Dette tvinger Docker til å bygge bildet igjen neste gang vi starter Docker Compose-filen:
cd src / main / docker docker-compose down docker rmi docker-spring-boot-postgres: siste docker-compose up
Så etter at vi har stoppet containerne, sletter vi applikasjonen Docker-image. Vi starter deretter Docker Compose-filen igjen, som bygger om applikasjonsbildet på nytt.
Her er applikasjonsutgangen:
Ferdig skanning av vår datalager på 180 ms. Fant 1 JPA repository grensesnitt. [...] Antall kunder: 0 Sparer ny kunde ... Antall kunder: 1
Spring Boot finner vårt tomme kundedepot. Derfor starter vi uten kunde, men oppretter deretter en vellykket.
8. Konklusjon
I denne korte opplæringen startet vi med å lage en Spring Boot-applikasjon for PostgreSQL. Deretter skrev vi en Docker Compose-fil for å kjøre applikasjonsbeholderen vår med en PostgreSQL-container.
Til slutt opprettet vi en kundeenhet og et lager, som tillot oss å lagre en kunde i PostgreSQL.
Som vanlig kan kildekoden for denne opplæringen bli funnet på GitHub.