Docker v Azure pro aplikaci PensionPlanner

Praktický návod pro laika: co je Docker, jak se používá v Azure, jaké Azure resources budeš potřebovat a jak nasadit aplikaci PensionPlanner.

1. Co je vlastně Docker

Docker je způsob, jak zabalit aplikaci do kontejneru.

Kontejner obsahuje: - aplikaci - runtime a knihovny - systémové závislosti - startovací příkaz

Díky tomu aplikace běží stejně: - na notebooku vývojáře - v CI/CD pipeline - v Azure

Jednoduše: - source code = zdroják - Docker image = zabalená aplikace - container = spuštěná instance image - registry = sklad image souborů

2. Jak Docker funguje v Azure

V Azure se obvykle používá tento tok:

flowchart LR A[Zdrojový kód PensionPlanner] --> B[Docker build] B --> C[Docker image] C --> D[Azure Container Registry] D --> E[Azure služba pro běh kontejneru] E --> F[Veřejná URL aplikace] E --> G[Logy a monitoring]

Typický postup: 1. vytvoříš Dockerfile 2. z aplikace uděláš Docker image 3. image nahraješ do Azure Container Registry (ACR) 4. Azure si image stáhne z registry 5. Azure kontejner spustí 6. uživatelé jdou na veřejnou URL

3. Jaké Azure varianty existují

Když chceš v Azure provozovat Docker, máš několik možností:

A. Azure Container Apps

Nejlepší start pro většinu nových webových aplikací.

Výhody: - nemusíš spravovat servery - umí škálovat nahoru i dolů - umí i scale-to-zero u některých scénářů - jednoduché nasazení z Docker image - dobrý poměr jednoduchost / moderní architektura

Nevýhody: - je tam víc Azure pojmů než u úplně nejjednodušších služeb - některé enterprise scénáře jsou složitější

Pro PensionPlanner bych pro běžný moderní deployment doporučil právě Azure Container Apps.

B. Azure App Service for Containers

Jednodušší model pro jednu webovou appku.

Výhody: - jednoduchý web hosting - dobré pro klasický web/API - snadno se napojuje custom domain a SSL

Nevýhody: - méně kontejnerově-native než Container Apps - horší fit pro složitější mikroservisy a background workers

Dobrá volba, pokud je PensionPlanner jedna webová aplikace a nechceš moc řešit cloud detaily.

C. Azure Kubernetes Service (AKS)

Nejsilnější, ale nejsložitější varianta.

Výhody: - maximum kontroly - standard pro větší platformy - vhodné pro více služeb, složitou orchestraci a enterprise

Nevýhody: - výrazně složitější provoz - vyšší nároky na znalosti i správu - pro začátek často zbytečný overkill

Pro laický nebo první deployment PensionPlanner to nedává smysl, pokud k tomu není konkrétní důvod.

D. Azure Virtual Machine + Docker

Docker si pustíš na vlastní VM.

Výhody: - maximální kontrola - snadné pochopit, protože je to „server, na kterém něco běží“

Nevýhody: - musíš spravovat OS, security, aktualizace, reverse proxy, monitoring, backupy - nejvíc ruční práce

Hodí se spíš pro speciální případy, ne jako doporučený cloud-native start.

4. Co bych doporučil pro PensionPlanner

Doporučená varianta pro začátek

Azure Container Apps + Azure Container Registry + Log Analytics + databáze podle potřeby

To je rozumný kompromis mezi: - jednoduchostí - moderním přístupem - škálováním - provozní nenáročností

5. Jaké resources budeš v Azure typicky potřebovat

Níže je praktický seznam od povinných po volitelné.

Základní minimum

1. Resource Group

Logický obal pro všechny resources.

Příklad: - rg-pensionplanner-prod

2. Azure Container Registry (ACR)

Sem se ukládají Docker images.

Příklad: - acrpensionplannerprod

3. Azure Container Apps Environment

Společné prostředí pro Container Apps.

Příklad: - cae-pensionplanner-prod

4. Azure Container App

Samotná běžící aplikace.

Příklad: - ca-pensionplanner-web

5. Log Analytics Workspace

Logy, diagnostika, troubleshooting.

Příklad: - log-pensionplanner-prod

Velmi pravděpodobně budeš potřebovat také

6. Databázi

Podle typu aplikace.

Nejčastější varianty: - Azure SQL Database - Azure Database for PostgreSQL - Azure Database for MySQL

Pro plánovací / business aplikaci typu PensionPlanner bývá databáze skoro jistota.

7. Key Vault

Bezpečné uložení secrets: - connection stringy - API klíče - hesla - certifikáty

Doporučeno prakticky vždy, pokud aplikace není úplně demo.

8. Storage Account

Pokud aplikace pracuje se soubory, exporty, importy, reporty nebo attachmenty.

Volitelné, ale často užitečné

9. Custom domain + TLS

Aby aplikace nebyla jen na Azure generované URL.

Např.: - app.pensionplanner.cz - portal.pensionplanner.cz

10. Front Door / Application Gateway / WAF

Pokud chceš: - lepší security - routing - CDN-like edge vstup - web application firewall

11. CI/CD pipeline

Např.: - GitHub Actions - Azure DevOps Pipelines

Aby se nový build nasadil automaticky.

12. Application Insights / OpenTelemetry monitoring

Na chyby, performance a telemetry.

6. Jednoduchá mentální mapa

Co je povinné skoro vždy

Resource Group
Dockerfile
Container Registry
Container runtime v Azure
veřejný endpoint
logy

Co je povinné podle aplikace

databáze
secrets
storage
custom domain
CI/CD

7. Jak vypadá nejběžnější architektura pro PensionPlanner

flowchart TD U[Uživatel] --> DNS[Custom domain / DNS] DNS --> APP[Azure Container App: PensionPlanner] APP --> ACR[Azure Container Registry] APP --> DB[Azure SQL / PostgreSQL] APP --> KV[Azure Key Vault] APP --> LOG[Log Analytics / Monitoring] APP --> ST[Storage Account - volitelné]

8. Co budeš potřebovat připravit ještě před Azure částí

Než začneš klikat v Azure, potřebuješ si ujasnit:

A. Jaký typ aplikace PensionPlanner je

web frontend?
backend API?
oboje?
background joby / plánovač?

B. Na jakém portu běží

V kontejneru obvykle např.: - 80 - 3000 - 5000 - 8080

C. Jaké má environment variables

Např.: - ASPNETCORE_ENVIRONMENT - NODE_ENV - DATABASE_URL - ConnectionStrings__Default - JWT_SECRET

D. Jestli potřebuje persistentní data

Důležité pravidlo: kontejner není místo pro trvalé ukládání dat.

Do kontejneru patří aplikace. Data patří do: - databáze - storage - externích služeb

9. Doporučené naming conventions pro PensionPlanner

Příklad pro prostředí prod:

Resource group: rg-pensionplanner-prod
ACR: acrpensionplannerprod
Container Apps env: cae-pensionplanner-prod
Container app: ca-pensionplanner-web
Log Analytics: log-pensionplanner-prod
Key Vault: kv-pensionplanner-prod
SQL server: sql-pensionplanner-prod
SQL database: sqldb-pensionplanner-prod
Storage: stpensionplannerprod

Pro dev a test analogicky: - rg-pensionplanner-dev - rg-pensionplanner-test

10. Co stojí peníze

V Azure platíš typicky za: - běh aplikace (CPU/RAM) - registry storage a operace - databázi - logy a monitoring - storage - síťové služby

Prakticky

Nejdražší nebývá samotný Docker. Nejdražší bývá: - databáze - zbytečně velké sizingy - moc logů - enterprise síťové služby

11. Nejjednodušší doporučený deployment postup

Varianta: Azure Container Apps

vytvořit Resource Group
vytvořit Log Analytics
vytvořit Container Apps Environment
vytvořit ACR
buildnout Docker image
pushnout image do ACR
vytvořit Container App
nastavit environment variables a secrets
napojit databázi
otestovat URL
případně přidat custom domain
připojit CI/CD

12. Ukázkový Dockerfile pro PensionPlanner

Protože neznám technologii aplikace, dávám generickou ukázku pro webovou aplikaci. Přizpůsobíš ji podle stacku.

Varianta A: jednoduchý Node.js příklad

FROM node:20-alpine AS base
WORKDIR /app

COPY package*.json ./
RUN npm ci --omit=dev

COPY . .

ENV PORT=8080
EXPOSE 8080

CMD ["npm", "start"]

Varianta B: jednoduchý .NET 8 příklad

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /out

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY --from=build /out .
ENV ASPNETCORE_URLS=http://+:8080
EXPOSE 8080
ENTRYPOINT ["dotnet", "PensionPlanner.dll"]

Pokud je aplikace v Javě, Pythonu, PHP nebo jiném stacku, Dockerfile bude jiný.

13. Ukázkový Azure CLI script pro vytvoření základních resources

Tento script vytváří základ pro nasazení PensionPlanner do Azure Container Apps.

Poznámka: názvy ACR a Storage musí být v Azure globálně unikátní.

#!/usr/bin/env bash
set -euo pipefail

APP_NAME="PensionPlanner"
LOCATION="westeurope"
ENV_NAME="prod"

RESOURCE_GROUP="rg-pensionplanner-${ENV_NAME}"
LOG_ANALYTICS="log-pensionplanner-${ENV_NAME}"
CONTAINERAPPS_ENV="cae-pensionplanner-${ENV_NAME}"
CONTAINER_APP="ca-pensionplanner-web"
ACR_NAME="acrpensionplanner${ENV_NAME}"
IMAGE_NAME="pensionplanner-web"
IMAGE_TAG="v1"
TARGET_PORT="8080"

az group create \
  --name "$RESOURCE_GROUP" \
  --location "$LOCATION"

az monitor log-analytics workspace create \
  --resource-group "$RESOURCE_GROUP" \
  --workspace-name "$LOG_ANALYTICS" \
  --location "$LOCATION"

LOG_ANALYTICS_ID=$(az monitor log-analytics workspace show \
  --resource-group "$RESOURCE_GROUP" \
  --workspace-name "$LOG_ANALYTICS" \
  --query customerId -o tsv)

LOG_ANALYTICS_KEY=$(az monitor log-analytics workspace get-shared-keys \
  --resource-group "$RESOURCE_GROUP" \
  --workspace-name "$LOG_ANALYTICS" \
  --query primarySharedKey -o tsv)

az containerapp env create \
  --name "$CONTAINERAPPS_ENV" \
  --resource-group "$RESOURCE_GROUP" \
  --location "$LOCATION" \
  --logs-workspace-id "$LOG_ANALYTICS_ID" \
  --logs-workspace-key "$LOG_ANALYTICS_KEY"

az acr create \
  --name "$ACR_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --location "$LOCATION" \
  --sku Basic \
  --admin-enabled false

14. Ukázkový script pro build a push Docker image

#!/usr/bin/env bash
set -euo pipefail

ENV_NAME="prod"
RESOURCE_GROUP="rg-pensionplanner-${ENV_NAME}"
ACR_NAME="acrpensionplanner${ENV_NAME}"
IMAGE_NAME="pensionplanner-web"
IMAGE_TAG="v1"

ACR_LOGIN_SERVER=$(az acr show \
  --name "$ACR_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --query loginServer -o tsv)

az acr login --name "$ACR_NAME"

docker build -t "${ACR_LOGIN_SERVER}/${IMAGE_NAME}:${IMAGE_TAG}" .
docker push "${ACR_LOGIN_SERVER}/${IMAGE_NAME}:${IMAGE_TAG}"

15. Ukázkový script pro vytvoření Container App PensionPlanner

#!/usr/bin/env bash
set -euo pipefail

ENV_NAME="prod"
LOCATION="westeurope"
RESOURCE_GROUP="rg-pensionplanner-${ENV_NAME}"
CONTAINERAPPS_ENV="cae-pensionplanner-${ENV_NAME}"
CONTAINER_APP="ca-pensionplanner-web"
ACR_NAME="acrpensionplanner${ENV_NAME}"
IMAGE_NAME="pensionplanner-web"
IMAGE_TAG="v1"
TARGET_PORT="8080"
INGRESS="external"
CPU="0.5"
MEMORY="1.0Gi"
MIN_REPLICAS="1"
MAX_REPLICAS="3"

ACR_LOGIN_SERVER=$(az acr show \
  --name "$ACR_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --query loginServer -o tsv)

az containerapp create \
  --name "$CONTAINER_APP" \
  --resource-group "$RESOURCE_GROUP" \
  --environment "$CONTAINERAPPS_ENV" \
  --image "${ACR_LOGIN_SERVER}/${IMAGE_NAME}:${IMAGE_TAG}" \
  --target-port "$TARGET_PORT" \
  --ingress "$INGRESS" \
  --registry-server "$ACR_LOGIN_SERVER" \
  --cpu "$CPU" \
  --memory "$MEMORY" \
  --min-replicas "$MIN_REPLICAS" \
  --max-replicas "$MAX_REPLICAS" \
  --env-vars APP_NAME=PensionPlanner ASPNETCORE_ENVIRONMENT=Production

Po vytvoření si URL zjistíš takto:

az containerapp show \
  --name ca-pensionplanner-web \
  --resource-group rg-pensionplanner-prod \
  --query properties.configuration.ingress.fqdn -o tsv

16. Jak připojit databázi

Tohle je důležitější, než se zdá.

Webová aplikace často běží dobře v Dockeru, ale produkční problémy bývají tady: - špatný connection string - firewall pravidla - secret v plain textu - migrace databáze - špatně nastavené TLS / SSL požadavky

Doporučení: - connection string nedávat natvrdo do image - používat environment variables nebo Key Vault - databázi provozovat jako samostatný managed resource

Příklad env proměnné:

az containerapp update \
  --name ca-pensionplanner-web \
  --resource-group rg-pensionplanner-prod \
  --set-env-vars DATABASE_URL='postgres://USERNAME:PASSWORD@HOST:5432/pensionplanner'

Lepší enterprise varianta: - heslo uložit do Key Vault - aplikaci dát managed identity - secret číst bezpečně

17. Co řešit z pohledu security

Minimum: - nepoužívat hesla natvrdo v repozitáři - použít Key Vault nebo secrets v Container Apps - omezit přístup k databázi - zapnout TLS/HTTPS - pravidelně rebuildovat image kvůli security patchům - mít oddělené dev, test, prod

Pokud bude PensionPlanner pracovat s osobními nebo finančními daty, security a audit budou důležitější než samotný Docker deployment.

18. Co řešit z pohledu provozu

Po nasazení nekončí práce. Je potřeba řešit: - logy - health checks - restart policy - monitoring - alerty - zálohy databáze - rollback při špatném releasu

Doporučené minimum: - sledovat HTTP 5xx chyby - sledovat start failures kontejneru - sledovat využití CPU/RAM - mít jednoduchý rollback na předchozí image tag

19. Nejčastější chyby začátečníků

1. Uložení dat do filesystemu kontejneru

Po restartu nebo redeployi o data přijdeš.

2. Příliš velký Docker image

Zbytečně pomalé buildy a deploye.

3. Chybějící readiness / health kontrola

Azure nepozná dobře, jestli aplikace opravdu běží správně.

4. Tajné údaje přímo v Dockerfile

Bezpečnostní problém.

5. Použití AKS moc brzy

Spousta složitosti bez reálného benefitu.

6. Žádné oddělení prostředí

Dev a prod se začnou míchat.

20. Kdy zvolit jinou variantu než Container Apps

Zvol App Service for Containers, pokud:

máš jednu webovou aplikaci
chceš co nejjednodušší provoz
nepotřebuješ mikroservisní architekturu

Zvol AKS, pokud:

budeš provozovat více služeb
chceš pokročilou orchestraci
potřebuješ enterprise Kubernetes standard
máš na to tým a provozní kapacitu

Zvol VM + Docker, pokud:

chceš full control
máš důvod jít mimo managed platformy
akceptuješ ruční správu serveru

21. Co bych doporučil jako realistický první krok

Pro PensionPlanner bych šel takto:

Fáze 1 — MVP / první produkční nasazení

Azure Container Registry
Azure Container Apps
Log Analytics
databáze
Key Vault
1 custom domain
jednoduchý CI/CD pipeline

Fáze 2 — stabilizace

monitoring a alerty
oddělené dev / test / prod
lepší tagging image
rollback postup
security review

Fáze 3 — růst

background worker kontejnery
plánované joby
Front Door / WAF
více prostředí / regionů
případně AKS, pokud na to bude skutečný důvod

22. Doporučené minimum checklist

Aby šel PensionPlanner bezpečně nasadit

[ ] máme Dockerfile
[ ] aplikace umí běžet z env proměnných
[ ] data nejsou ukládaná do lokálního filesystemu kontejneru
[ ] máme vybraný typ databáze
[ ] máme Resource Group
[ ] máme ACR
[ ] máme Container Apps Environment
[ ] máme Container App
[ ] máme logování
[ ] máme secrets mimo zdroják
[ ] máme produkční URL
[ ] máme rollback plán

23. Krátké shrnutí pro ne-technické rozhodnutí

Pokud chceš odpověď jednou větou:

Docker v Azure znamená, že aplikaci PensionPlanner zabalíš do kontejneru, uložíš image do Azure Container Registry a Azure ji pak spustí jako managed službu — ideálně přes Azure Container Apps, doplněné o databázi, logy a secrets management.

24. Doporučení na závěr

Pokud ještě není rozhodnuté, na čem PensionPlanner běží, doporučený směr je:

potvrdit technologický stack
připravit produkční Dockerfile
rozhodnout databázi
nasadit první verzi do Azure Container Apps
až potom řešit CI/CD, custom domain, scaling a security hardening do detailu

25. Co bude potřeba doplnit pro finální implementační návod

Aby z toho šel udělat úplně konkrétní produkční runbook, bude potřeba znát: - stack aplikace (.NET, Node.js, Python, ...) - jestli je to jen web nebo i API + worker - jaká databáze má být použitá - jaké domény se mají použít - jestli chceš dev/test/prod - jestli chceš deployment přes GitHub Actions nebo Azure DevOps

Pak se z tohoto dokumentu dá udělat přesný deployment blueprint krok za krokem.