Środowisko deweloperskie z Dockerem

Konfiguracja środowiska deweloperskiego z Dockerem

Docker już od dłuższego czasu zyskuje niesamowicie na popularności, co moim zdaniem jest w dużej mierze zasługą między innymi bardzo prostej konfiguracji i ogromnej społeczności. Jeżeli miałeś okazję słyszeć o Dockerze, ale niekoniecznie zagłębiałeś się w temat tego jak w prosty sposób mógłby pomóc Ci w codziennej pracy, to dzisiaj pokażę Ci jak przy jego pomocy przygotować sobie proste środowisko deweloperskie do pracy nad nową aplikacją.

Co będziemy budować?

Przygotujemy sobie konfigurację obrazów/kontenerów dla typowej aplikacji składającej się z API (PHP), frontendu (np. Vue.js) i bazy danych (MySQL).

Czego będziemy potrzebować?

  • Docker (kto by się spodziewał). Możesz go pobrać z oficjalnej strony, o tutaj.
  • Jakiegoś pustego katalogu na naszym komputerze

Struktura plików

Katalog główny:
	app:
    	Dockerfile.development
        ...pliki Vue
	api:
	    Dockerfile.development
		docker:
        	nginx.conf
        ...pliki API
	docker-compose.yml

Główny katalog dzielimy na dwa podkatalogi (będziemy w nich przechowywać pliki kolejno naszego frontendu, czyli np. Vue.js w katalogu app i backendu czyli API w katalogu api). Na tym samym poziomie mamy jeszcze plik docker-compose.yml w którym trzymamy konfigurację naszych kontenerów. Każda z części ma swój własny plik Dockerfile w którym przechowujemy konfigurację obrazów z których później będziemy odpalać nasze kontenery.

Konfiguracja Dockerfile dla aplikacji (frontend)

FROM node:10

WORKDIR /app

EXPOSE 8080

CMD yarn serve 

Nasz obraz oprzemy o Node w wersji 10. W kolejnej linii deklarujemy nasz katalog roboczy na kontenerze, czyli tak naprawdę miejsce w którym będziemy przechowywać pliki naszej aplikacji. W naszym przykładzie będziemy uruchamiać serwer deweloperski Vue.js na domyślnym porcie 8080, więc ten port wystawiamy na zewnątrz (EXPOSE 8080). Ostatnia linia to komenda która zostanie uruchomiona w momencie startu naszego kontenera i w tym przypadku jest to po prostu uruchomienie serwera dostarczanego przez Vue.

Konfiguracja Dockerfile dla API (backend)

FROM php:7.3-fpm 

WORKDIR /var/www

RUN apt-get update && apt-get install -y \
    build-essential \
    unzip \
    git \
    curl

RUN docker-php-ext-install pdo_mysql mbstring exif pcntl

RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

EXPOSE 9000

CMD php-fpm

Tutaj wiele rzeczy jest analogicznych jak w przypadku konfiguracji obrazu dla frontendu, z wyjątkiem kilku dodatkowych bibliotek/rozszerzeń które doinstalowujemy do naszego bazowego obrazu, czyli PHP-FPM w wersji 7.3.

Konfiguracja kontenerów (Docker Compose)

version: "3"

services:
  app: 
    build: 
      context: ./app
      dockerfile: Dockerfile.development
    volumes:
      - ./app:/app
    ports:
      - 8080:8080
    container_name: app
    
  api:
    build:
      context: ./api
      dockerfile: Dockerfile.development
    environment:
      - DB_HOST=database
      - DB_USERNAME=root
      - DB_PASSWORD=password
      - DB_DATABASE=test
    volumes:
      - ./api:/var/www
    container_name: api

  server:
    image: nginx:alpine
    ports:
      - 80:80
    volumes:
      - ./api:/var/www
      - ./api/docker/nginx.conf:/etc/nginx/conf.d/app.conf
    container_name: api-server

  database:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD=password
      - MYSQL_DATABASE=test
    ports:
      - 3306:3306
    container_name: db

Na samym początku ustalamy wersję Docker Compose dla której przygotowujemy naszą konfigurację (sekcja services). U nas jest to akurat wersja 3. W sekcji services mamy zadeklarowane 4 kontenery, zaczynając od góry jest to nasz frontend, backend rozbity na dwa kontenery (PHP i Nginx) i bazę danych (MySQL).

Na poziomie każdego kontenera musimy wskazać obraz z którego chcemy uruchomić dany kontener. Jeżeli mamy własną konfigurację to tak jak w przypadku kontenera app i api w sekcji build deklarujemy miejsce w którym przechowujemy nasz plik Dockerfile. Natomiast jeżeli korzystamy z zewnętrznych obrazów (kontener server i database) to jego nazwę podajemy w sekcji image.

Sekcja volumes mapuje pliki pomiędzy kontenerem, a naszym komputerem. Czyli dla przykładu zapis ./app:/app powoduje, że pliki z naszego katalogu app będę synchronizowane na żywo z tymi w katalogu app na kontenerze.

Sekcja ports mapuje nasze porty z tymi wystawianymi przez nasz kontener. Czyli np. zapis 8080:8080 spowoduje że nasz lokalny port 8080 będzie trafiał do portu 8080 dokładnie na tym kontenerze. Nie możemy mieć tego samego portu zmapowanego w kilku kontenerach.

Jak to uruchomić?

docker compose up -d

(-d spowoduje, że nasze kontenery zostaną uruchomione w tle)

Jeżeli zmienimy konfigurację plików Dockerfile albo samego Docker Compose to musimy przebudować nasze kontenery poprzez dodanie do powyższej komendy jeszcze --build.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *