3. Dockerfiles voor docker compose

Meer informatie over Docker compose

In deze opdracht maak je een docker compose aan. Docker compose wordt gebruikt om meerdere projecten in één keer te beheren en te configureren. Het stelt je in staat om de configuratie van je containers in één bestand te definiëren, zodat je eenvoudig meerdere containers kunt opstarten, stoppen en beheren met één enkele opdracht.

Het project voor deze opdracht staat in de directory Docker-Demo-Project/studentversie/opdracht2.

Voor deze opdracht is de dockerfile voor de backend gegeven. Elke stap zal hierin uitgelegd worden, waarna de dockerfile voor de frontend zelf gemaakt moet worden.

Dockerfile backend

De Dockerfile van de backend is te vinden in Docker-Demo-Project/studentversie/opdracht2/backend/backend.

Haalt de docker image op voor de basis .net versie 8.0 met als fase base

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base

Maakt een USER aan. Deze USER is standaard een root user. Door het zetten van de USER voorkom je mogelijke gevaren qua security.

USER app

Geeft aan welke directory gebruikt moet worden binnen de container.

WORKDIR /app

Zet de poorten open die nodig zijn voor HTTP (8080) en HTTPS (8081)

EXPOSE 8080
EXPOSE 8081

Maakt nog een dotnet container aan en zet de working directory op een locatie. Hierin wordt ook de configuratie gezet voor het gebruik van Release in plaats van Debug. Hierbij wordt de fase op build gezet

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
ARG BUILD_CONFIGURATION=Release

De working directory wordt gezet op /src.

WORKDIR /src

Kopieert de backend.csproj naar de /src map die net als WORKDIR is ingesteld. Verder haalt het alle benodigde NuGET-packages uit .csproj op.

COPY ["backend.csproj", "./"]
RUN dotnet restore "./backend.csproj"

Kopieert de rest van de code naar de /src map.

COPY . .

Runt het project

• -c $BUILD_CONFIGURATION: zet de configuratie vanuit stap 5
• -o /app/build: zet de output in de directory /app/build

RUN dotnet build "./backend.csproj" -c $BUILD_CONFIGURATION -o /app/build

Start een nieuwe fase publish met als basis build waarbij de configuratie opnieuw op Release gezet wordt.

FROM build AS publish
ARG BUILD_CONFIGURATION=Release

Publiceert het project, zet het in de /app/publish directory en zorgt ervoor dat er geen executable file wordt aangemaakt met /p:UseAppHost=false.

RUN dotnet publish "./backend.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false

Start een nieuwe fase final met als basis base en zet de WORKDIR op /app.

FROM base AS final
WORKDIR /app

Kopieert van de code van de fase publish uit map /app/publish naar .

• . staat voor de huidige directory, in dit geval de WORKDIR die zojuist gezet is.

COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "backend.dll"]

Complete dockerfile voor backend

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
USER app
WORKDIR /app
EXPOSE 8080
EXPOSE 8081

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
ARG BUILD_CONFIGURATION=Release
WORKDIR /src
COPY ["backend.csproj", "./"]
RUN dotnet restore "./backend.csproj"
COPY . .
RUN dotnet build "./backend.csproj" -c $BUILD_CONFIGURATION -o /app/build

FROM build AS publish
ARG BUILD_CONFIGURATION=Release
RUN dotnet publish "./backend.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "backend.dll"]

Opdracht 2.1: Dockerfile frontend

Nu is het aan jou om de dockerfile te maken voor de frontend.

Stap 1: Open de directory Docker-Demo-Project/studentversie/opdracht2/frontend in een editor.

Stap 2: Open het bestand met de naam Dockerfile

Stap 3: Vul de dockerfile aan met dezelfde stappen van Dockerfile voor HTML pagina

• Zorg er alleen voor dat de poort 4080 wordt gebruikt en niet poort 3080. Door een unieke poort te gebruiken zorg je ervoor dat je beide projecten tegelijk kunnen runnen.

Antwoord - Volledige dockerfile

FROM nginx

# copy app to nginx public folder
COPY /content /usr/share/nginx/html

# copy custom nginx config
COPY nginx.conf /etc/nginx/

# set working directory
WORKDIR /app

# add app
COPY . ./

# open port 4080 for trafic
EXPOSE 4080

# start app
CMD ["nginx", "-g", "daemon off;"]

Opdracht 2.2: Docker compose voor hele project

Om nu te zorgen dat alle projecten draaien met docker, gaan we werken in het docker-compose.yaml document. Het voordeel van docker compose is dat alle applicaties met één commando (docker compose watch) gebuild en gestart kunnen worden.

Let op

Bij het kopiëren van de regels, kan het zijn dat door indentatie fouten het niet goed herkend wordt. Pas dit zelf aan door tabs toe te voegen.

Stap 1: Navigeer naar de directory van Docker-Demo-Project/studentversie/opdracht2.

Stap 2: Open het document genaamd docker-compose.yaml.

• Hierin is al een deel gegeven, maar deze zal je zelf moeten aanvullen om het werkend te maken

Stap 3: Vul het document aan met de volgende stappen

Stap 3.1: Vul de api: aan met het volgende

context: Om aan te geven wat de context is voor het backend project. dockerfile: Om aan te geven waar de Dockerfile te vinden is binnen de aangegeven context.

build:
  context: ./backend/backend/
  dockerfile: ./Dockerfile

restart: Zet de status voor het restarten op always waardoor de container altijd opnieuw gestart zal worden ongeacht de exit status.

restart: always

Stap 3.2: Vul de client: aan met het volgende:

build: Net zoals bij de api:, moeten de context en dockerfile worden gezet.

build:
  context: ./frontend/
  dockerfile: ./Dockerfile

ports: Hiermee worden de referentie gezet tussen de docker poorten en de poorten op je eigen laptop.

• De linker poort geeft de poort aan op de eigen machine
• De rechter poort geeft de poort aan binnen de container die is gedefinieerd in de dockerfile.

ports:
  - "4080:4080"

restart: Opnieuw geldt hier hetzelfde als bij de api:

restart: always

depends_on: Hiermee geef je de volgorde aan van het opstarten van de services. In dit geval wordt dus eerst de service api opgestart voordat de client service opgestart zal worden.

• Binnen de compose zijn de services db, api, client

depends_on:
  - api

develop: Geeft aan welke configuraties gebruikt zullen worden tijdens de development van de client service. In dit geval wordt tijdens het runnen van de docker compose watch command gekeken of er aanpassingen worden gedaan aan de directory /frontend. Als dit zo is, wordt de action rebuild uitgevoerd. Dit zorgt ervoor dat de docker image automatisch opnieuw wordt gebuild en opgestart.

develop:
  watch:
    - action: rebuild
      path: ./frontend/

Antwoord - Volledige docker-compse

version: "3.8"
services:
  db:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: SuperVeiligWachtwoord123@!
    volumes:
      - ./database:/docker-entrypoint-initdb.d
    ports:
      - "5432:5432"

  api:
    build:
      context: ./backend/backend/
      dockerfile: ./Dockerfile
    ports:
      - "5080:8080"
      - "5081:8081"
    restart: always
    depends_on:
      - db
    develop:
      watch:
        - action: rebuild
          path: ./backend/

  client:
    build:
      context: ./frontend/
      dockerfile: ./Dockerfile
    ports:
      - "4080:4080"
    restart: always
    depends_on:
      - api
    develop:
      watch:
        - action: rebuild
          path: ./frontend/

volumes:
  pgdata:

Gelukt

Je hebt nu succesvol een docker compose file aangemaakt met de juiste dockerfiles

Opdracht 2.3

Nu dat alle bestanden voor docker zijn aangemaakt en ingevuld, kan het project worden gestart.

Stap 1: Open een CMD/Terminal en navigeer naar de directory van Docker-Demo-Project/studentversie/opdracht2

Stap 2: Run de volgende commando in je CMD/Terminal om je docker containers te builen en op te starten

docker compose watch

Stap 3: Ga naar http://localhost:4080/ en kijk of de website wordt ingeladen.

Stap 4: Test of de website naar behoren werkt door nieuwe taken toe te voegen, af te vinken en te verwijderen.

Stap 5: Stop en start / herstart de container en kijk of de zojuist toegevoegde taken nog aanwezig zijn.

Gelukt

Het is gelukt om een docker compose aan te maken en te runnen. Hiermee is nu een frontend, backend en database opgestart

---

Volgende stap: 4. Docker volumes