MyCodeSchool

Pasul 1 din 5

Docker

Pasul 1 din 5 · Ce construiești

  • Docker
  • Java
  • Mediu
  • 15 minute

Docker Compose de la zero: aplicația Java și MySQL

Ai o aplicație Spring Boot care citește anunțuri dintr-o bază MySQL. Pe calculatorul tău merge. Vrei să pornească la fel oriunde, cu o singură comandă și fără să instalezi MySQL:

terminal, în folderul anunturi
$ docker compose up -d
[+] up 5/5
 ✔ Network anunturi_default Created
 ✔ Volume anunturi_date-db  Created
 ✔ Container anunturi-db-1  Healthy
 ✔ Container anunturi-api-1 Started
 ✔ Container anunturi-web-1 Started
$ curl localhost:8080/api/anunturi
[{"id":1,"text":"Ora de sport se mută joi"},{"id":2,"text":"Concurs de programare pe 20 noiembrie"}]

Trei containere: baza de date, aplicația Java și un nginx care le primește pe toate la adresa localhost:8080. Duratele din dreapta fiecărui rând au fost scoase, pentru lizibilitate.

Pasul 2 din 5

O sesiune în terminal, comandă cu comandă

Folderul anunturi conține proiectul Maven, un Dockerfile, un compose.yaml și un fișier .env. Pe toate le găsești în pasul următor. Apasă pe „Linia următoare” și urmărește ce rulează.

terminal
docker run -d --name proba-db \  -e MYSQL_ROOT_PASSWORD=parola mysql:8.4docker ps --format "{{.Names}}: {{.Status}}"docker rm -f proba-dbdocker build -t anunturi-api .docker compose up -ddocker compose ps --format "{{.Service}}: {{.Status}}"curl localhost:8080/api/anunturidocker compose down

Containere pornite

Ce afișează terminalul


      

  1. Linia 1. docker run pornește un container din imaginea oficială mysql:8.4. -d îl lasă să ruleze în fundal, -e îi dă parola de root. Docker afișează id-ul containerului.
  2. Linia 3. docker ps listează containerele pornite. Ai un MySQL funcțional, fără să-l fi instalat. E doar o probă, așa că îl oprești imediat.
  3. Linia 4. docker rm -f oprește și șterge containerul. Imaginea mysql:8.4 rămâne pe disc, pentru data viitoare.
  4. Linia 5. docker build citește Dockerfile-ul din folderul curent, punctul de la final, și construiește imaginea aplicației. Prima dată durează, pentru că Maven descarcă dependențele.
  5. Linia 6. docker compose up -d citește compose.yaml: creează rețeaua și volumul, pornește baza, așteaptă să fie sănătoasă, apoi pornește aplicația și nginx.
  6. Linia 7. Toate trei rulează. Doar db are o stare de sănătate, pentru că doar ea are un healthcheck.
  7. Linia 8. Cererea ajunge la nginx, pe portul 8080. nginx o trimite aplicației, care citește din MySQL și răspunde cu JSON.
  8. Linia 9. docker compose down oprește și șterge containerele și rețeaua. Volumul cu datele bazei rămâne.
  9. Gata. La următorul up -d, baza pornește cu datele de acum. Șterge și volumul doar cu down -v, și doar când chiar vrei asta.

Prezice ieșirea

Înainte de down, ai adăugat în bază un al treilea anunț. Rulezi din nou docker compose up -d și apoi curl. Câte anunțuri primești?

Răspuns: 3.

Containerul e nou, dar MySQL își ține fișierele în volumul date-db, pe care down nu l-a atins. După down -v ai fi primit doar cele 2 anunțuri inițiale.

Pasul 3 din 5

Fișierele din spatele comenzilor

Patru idei, de la un singur container la o aplicație gata de urcat pe server. La final, două erori pe care le vei vedea sigur.

Imagine, container, volum

O imagine e un șablon care nu se schimbă: sistemul de fișiere și comanda de pornire. Un container e o imagine pornită, cu procesul ei. Din aceeași imagine mysql:8.4 poți porni zece containere.

Tot ce scrie un container în interior dispare când îl ștergi. Datele care trebuie păstrate, cum sunt fișierele unei baze, stau într-un volum: un folder administrat de Docker și montat în container.

Dockerfile în două etape

Dockerfile
FROM maven:3.9-eclipse-temurin-21 AS buildWORKDIR /appCOPY pom.xml .RUN mvn -B -q dependency:go-offlineCOPY src srcRUN mvn -B -q -DskipTests packageFROM eclipse-temurin:21-jre-alpineWORKDIR /appCOPY --from=build /app/target/*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

Prima etapă, build, are Maven și JDK-ul întreg: compilează și produce fișierul .jar. A doua pornește de la o imagine care are doar JRE și copiază din prima etapă numai .jar-ul. Uneltele de build nu ajung în imaginea finală.

Fiecare instrucțiune e un strat salvat în cache. pom.xml e copiat separat de cod, așa că după o modificare în src, Docker refolosește stratul cu dependențele descărcate și rulează din nou doar compilarea:

Al doilea build, după o modificare în src

 => CACHED [build 4/6] RUN mvn -B -q dependency:go-offline
 => [build 5/6] COPY src src
 => [build 6/6] RUN mvn -B -q -DskipTests package

Aplicația își ia conexiunea din variabile de mediu, nu din valori scrise în cod:

application.properties
spring.datasource.url=${DB_URL}spring.datasource.username=${DB_USER}spring.datasource.password=${DB_PASSWORD}spring.sql.init.mode=always

compose.yaml: trei servicii, o rețea

compose.yaml
services:  db:    image: mysql:8.4    environment:      MYSQL_DATABASE: anunturi      MYSQL_USER: app      MYSQL_PASSWORD: ${DB_PASSWORD}      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}    volumes:      - date-db:/var/lib/mysql    healthcheck:      test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1"]      interval: 5s      retries: 10  api:    build: .    environment:      DB_URL: jdbc:mysql://db:3306/anunturi      DB_USER: app      DB_PASSWORD: ${DB_PASSWORD}    depends_on:      db:        condition: service_healthy  web:    image: nginx:alpine    volumes:      - ./web/index.html:/usr/share/nginx/html/index.html:ro      - ./web/default.conf:/etc/nginx/conf.d/default.conf:ro    ports:      - "8080:80"    depends_on:      - apivolumes:  date-db:

Compose pune toate serviciile într-o rețea comună, în care fiecare își poate găsi vecinii după nume. De aceea adresa bazei e jdbc:mysql://db:3306/anunturi: db e numele serviciului.

depends_on cu service_healthy pornește aplicația abia după ce mysqladmin ping reușește. Pentru api, compose caută imaginea anunturi-api, adică folderul plus serviciul. Ai construit-o deja, deci o refolosește.

Parolele nu stau în fișier. Compose le citește din .env, aflat lângă compose.yaml. Pe acesta nu-l urci niciodată în Git.

.env
DB_PASSWORD=parola-appDB_ROOT_PASSWORD=parola-root

Mai multe servicii, o singură intrare

web/default.conf
server {  listen 80;  root /usr/share/nginx/html;  location /api/ {    proxy_pass http://api:8080;  }}

Doar web are ports, deci doar el e accesibil din afară. nginx servește pagina și trimite tot ce începe cu /api/ către api:8080. Baza și aplicația rămân în rețeaua internă.

Pe un server, faci la fel, cu o singură schimbare: imaginea nu se mai construiește acolo. O publici într-un registru, cu docker push, iar în compose.yaml pui image: în loc de build:.

Diferența față de fișierul local

-    build: .
+    image: contul-tau/anunturi-api:1.0

Pe server copiezi compose.yaml, folderul web și un .env cu parole noi, apoi rulezi docker compose pull și docker compose up -d.

Capcană: localhost în container

Pe calculatorul tău, aplicația se conecta la localhost:3306. Lași adresa așa în compose.yaml, iar containerul api se oprește imediat:

api-1  | Caused by: com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure
api-1  |
api-1  | The last packet sent successfully to the server was 0 milliseconds ago. The driver has not received any packets from the server.
api-1  | Caused by: java.net.ConnectException: Connection refused (connect failed)

În container, localhost e chiar containerul api, iar acolo nu ascultă nicio bază. Aceeași eroare apare și dacă scoți condition: service_healthy: aplicația pornește înainte ca MySQL să fie gata.

Repară folosind numele serviciului, jdbc:mysql://db:3306/anunturi, și păstrând healthcheck-ul. Logurile le vezi cu docker compose logs api.

Capcană: portul e deja ocupat

Un container uitat dintr-un exercițiu anterior ascultă deja pe 8080. up -d pornește baza și aplicația, dar se oprește la nginx:

Error response from daemon: failed to set up container networking: driver failed programming external connectivity on endpoint anunturi-web-1 (e3653af6a928881009916d70a9f7da8b3e2bf8dbe4c725db2216540ff8f505be): Bind for 0.0.0.0:8080 failed: port is already allocated

Repară găsind containerul vinovat cu docker ps și oprindu-l, sau schimbă portul din stânga: "8081:80". Cel din dreapta, 80, e portul din container și rămâne la fel.

Pasul 4 din 5

Verifică-te

Cinci întrebări pe același proiect. Toate au fost verificate rulând comenzile.

1 din 5 · Alege varianta

Ce valoare pui la DB_URL pentru serviciul api?

Răspuns: db:3306.

Fiecare container are propriul localhost, iar 127.0.0.1 e același lucru. Baza e în alt container, la care ajungi prin numele serviciului.

2 din 5 · Prezice ieșirea

Ai trei anunțuri în bază. Rulezi docker compose down -v, apoi up -d și curl. Câte anunțuri primești?

Răspuns: 2.

-v șterge și volumul, deci MySQL pornește cu o bază goală. La pornire, Spring rulează schema.sql și data.sql, care adaugă din nou cele două anunțuri inițiale.

3 din 5 · Alege varianta

Ce serviciu are nevoie de ports ca aplicația să meargă din browser?

Răspuns: doar web.

Browserul vorbește doar cu nginx. nginx ajunge la api, iar api la db, prin rețeaua internă a compose-ului, fără porturi publicate. Cu cât publici mai puține porturi, cu atât expui mai puțin.

4 din 5 · Prezice ieșirea

Schimbi un text în src/main/resources/data.sql și rulezi din nou docker build. Ce pas apare cu CACHED?

Răspuns: dependency:go-offline.

Pașii de dinaintea lui COPY src depind doar de pom.xml, care nu s-a schimbat. Din COPY src încolo, totul rulează din nou.

5 din 5 · Alege varianta

Ce schimbi în compose.yaml pentru server, unde nu vrei să compilezi?

Răspuns: image în loc de build.

Serverul descarcă imaginea gata construită din registru. Restul fișierului rămâne la fel, iar parolele stau tot în .env, cu valori noi pentru server.

Pasul 5 din 5

Ce ai învățat

Structura proiectului

Așa arată folderul la final. Comanda care pornește totul e docker compose up -d, rulată din anunturi.

anunturi/

.env
.dockerignore
Dockerfile
compose.yaml
pom.xml
src/main/java/…/AnunturiApp.java
src/main/resources/application.properties
src/main/resources/schema.sql
src/main/resources/data.sql
web/index.html
web/default.conf

Continuă cu