MyCodeSchool

Pasul 1 din 5

Docker

Pasul 1 din 5 · Ce construiești

  • Docker
  • C#
  • Mediu
  • 15 minute

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

Ai un API ASP.NET Core 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 C# ș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 .NET, 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ă dotnet restore descarcă pachetele NuGet.
  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 mcr.microsoft.com/dotnet/sdk:8.0 AS buildWORKDIR /srcCOPY *.csproj .RUN dotnet restoreCOPY . .RUN dotnet publish -c Release -o /out --no-restoreFROM mcr.microsoft.com/dotnet/aspnet:8.0WORKDIR /appCOPY --from=build /out .EXPOSE 8080ENTRYPOINT ["dotnet", "Anunturi.dll"]

Prima etapă, build, pornește de la SDK-ul .NET: restaurează pachetele și publică aplicația în /out. A doua pornește de la aspnet, care are doar runtime-ul, și copiază din prima etapă numai folderul publicat. Compilatorul nu ajunge în imaginea finală.

Fiecare instrucțiune e un strat salvat în cache. .csproj e copiat separat de cod, așa că după o modificare în Program.cs, Docker refolosește stratul cu pachetele restaurate și rulează din nou doar publicarea:

Al doilea build, după o modificare în Program.cs

 => CACHED [build 4/6] RUN dotnet restore
 => [build 5/6] COPY . .
 => [build 6/6] RUN dotnet publish -c Release -o /out --no-restore

Aplicația citește conexiunea cu GetConnectionString("Db"). În ASP.NET Core, variabila de mediu ConnectionStrings__Db ajunge exact acolo: două caractere _ țin locul lui : din ConnectionStrings:Db.

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:      ConnectionStrings__Db: Server=db;Database=anunturi;User=app;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, în șirul de conexiune scrie Server=db: 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, șirul de conexiune avea Server=localhost. Lași adresa așa în compose.yaml, iar containerul api se oprește imediat:

api-1  | Unhandled exception. MySqlConnector.MySqlException (0x80004005): Unable to connect to any of the specified MySQL hosts.

Î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, Server=db, ș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 pui la Server= în șirul de conexiune al serviciului api?

Răspuns: Server=db.

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, aplicația creează tabelul și 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 Program.cs și rulezi din nou docker build. Ce pas apare cu CACHED?

Răspuns: dotnet restore.

Pașii de dinaintea lui COPY . . depind doar de Anunturi.csproj, care nu s-a schimbat. Din COPY . . î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
Anunturi.csproj
Dockerfile
Program.cs
compose.yaml
web/index.html
web/default.conf

Continuă cu