Dominik Jasiński

Dziś zagłębimy się w proces tworzenia własnych obrazów Docker, publikowania ich na Docker Hub oraz wykorzystywania w projektach i potokach CI/CD.

📋 Spis treści

Dlaczego warto tworzyć własne obrazy Docker?
Planowanie własnego obrazu PHP
Budowanie własnego obrazu PHP
Publikowanie na Docker Hub
Automatyzacja budowania z GitHub Actions
Podsumowanie

Dlaczego warto tworzyć własne obrazy Docker?

Tworzenie własnych obrazów Docker oferuje kilka istotnych korzyści:

Standaryzacja: Zapewnienie, że wszyscy deweloperzy i środowiska używają identycznych konfiguracji PHP.
Efektywność: Skrócenie czasów budowania poprzez wstępną instalację popularnych zależności.
Zgodność: Wymuszanie wymagań bezpieczeństwa i zgodności we wszystkich środowiskach.
Specjalizacja: Dostosowanie obrazów do konkretnych potrzeb aplikacji.
Kontrola: Niezależne zarządzanie wersjami PHP i rozszerzeniami od kodu aplikacji.
Skalowalność: Uproszczenie skalowania poprzez standaryzację jednostek wdrożeniowych.

W naszych poprzednich artykułach używaliśmy własnego obrazu PHP (dommin/php-8.4-fpm), który jest wstępnie skonfigurowany z PHP 8.4, popularnymi rozszerzeniami oraz narzędziami takimi jak Node.js i Composer. Zobaczmy, jak ten obraz został stworzony i jak możesz zbudować własny.

Planowanie własnego obrazu PHP

Przed zbudowaniem własnego obrazu, zdefiniuj swoje wymagania:

Kluczowe aspekty do rozważenia:

Obraz bazowy: Wybór odpowiedniego obrazu opartego na Debianie (php:8.4-fpm).
Rozszerzenia PHP: Lista rozszerzeń PHP, których Twoje aplikacje zazwyczaj potrzebują.
Pakiety systemowe: Identyfikacja zależności systemowych dla rozszerzeń PHP i narzędzi.
Dodatkowe narzędzia: Decyzja, czy potrzebujesz narzędzi takich jak Composer, Node.js czy Git.
Uprawnienia użytkownika: Rozważenie sposobu obsługi uprawnień plików między hostem a kontenerem.
Rozmiar vs. funkcjonalność: Balans między rozmiarem obrazu a potrzebną funkcjonalnością.

Przykład wymagań:

Dla aplikacji Laravel możesz potrzebować:

PHP 8.4 z FPM
Rozszerzenia: PDO, MySQL, PostgreSQL, GD, Zip, BCMath, Redis, itp.
Composer
Node.js i NPM
Git dla zależności Composera

Budowanie własnego obrazu PHP

Przeanalizujmy i ulepszmy Dockerfile używany do budowania naszego własnego obrazu PHP 8.4:

FROM php:8.4-fpm

ARG USER_ID=1000
ARG GROUP_ID=1000

RUN apt-get update && apt-get install -y --no-install-recommends \
    git curl unzip zip \
    libpng-dev libjpeg-dev libwebp-dev libfreetype6-dev \
    libonig-dev libxml2-dev libzip-dev \
    imagemagick libmagick++-dev \
    libpq-dev \
    autoconf g++ make \
    supervisor \
    rsync  \
    wget gnupg2 \
    && curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \
    && apt-get install -y nodejs \
    && npm install -g npm@latest \
    && pecl install redis imagick xdebug \
    && docker-php-ext-enable redis imagick xdebug \
    && docker-php-ext-configure gd --with-freetype --with-jpeg --with-webp \
    && docker-php-ext-install -j$(nproc) \
        pdo_mysql pdo_pgsql mysqli \
        zip bcmath pcntl intl \
        gd opcache \
    && wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - \
    && echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" > /etc/apt/sources.list.d/google-chrome.list \
    && apt-get update \
    && apt-get install -y google-chrome-stable \
    && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

RUN groupmod -g ${GROUP_ID} www-data \
    && usermod -u ${USER_ID} -g www-data www-data \
    && mkdir -p /var/www /var/log/supervisor /var/run/supervisor \
    && chown -R www-data:www-data /var/www /var/log/supervisor /var/run/supervisor

COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

WORKDIR /var/www

EXPOSE 9000

CMD ["php-fpm"]

Wyjaśnienie kluczowych komponentów:

Obraz bazowy: Używa oficjalnego obrazu PHP 8.4 FPM.
Dostosowanie użytkownika: Pozwala na dostosowanie ID użytkownika/grupy do uprawnień hosta.
Zależności systemowe: Instaluje biblioteki wymagane dla rozszerzeń PHP.
Node.js: Instaluje Node.js 22.x i npm do budowania zasobów frontendowych.
Rozszerzenia PHP: Instaluje i włącza popularne rozszerzenia PHP dla Laravel.
Composer: Kopiuje Composera z oficjalnego obrazu Composer.
Uprawnienia: Dostosowuje uprawnienia użytkownika i ustawia katalog roboczy.
Udostępnienie portu: Udostępnia port 9000 dla PHP-FPM.

Publikowanie na Docker Hub

Docker Hub to największe repozytorium obrazów kontenerowych. Publikowanie tam swojego obrazu czyni go dostępnym dla Twojego zespołu, potoków CI/CD i potencjalnie szerszej społeczności.

1. Utwórz konto na Docker Hub

Jeśli jeszcze go nie masz, zarejestruj się na Docker Hub.

2. Utwórz repozytorium

Kliknij "Create Repository" na swoim panelu Docker Hub
Nadaj mu odpowiednią nazwę (np. username/php)
Dodaj opis i ustaw widoczność (publiczne lub prywatne)
Kliknij "Create"

3. Zaloguj się do Docker Hub z CLI

docker login

Wprowadź swoją nazwę użytkownika i hasło Docker Hub po wyświetleniu monitu.

4. Zbuduj swój obraz

docker build -t username/php:8.4-fpm -f ./Dockerfile .

5. Wypchnij swój obraz na Docker Hub

docker push username/php:8.4-fpm

6. Zweryfikuj przesłanie

Odwiedź swoje repozytorium na Docker Hub, aby upewnić się, że obraz został pomyślnie przesłany.

Automatyzacja budowania z GitHub Actions

Ręczne budowanie i wypychanie obrazów może być żmudne. Zautomatyzujmy to za pomocą GitHub Actions.

Oto plik workflow, którego używasz (upewnij się, że Twoje sekrety są poprawnie skonfigurowane):

name: Build images

on:
  push:
    branches:
      - main

env:
  PHP_IMAGE: dommin/php-8.4-fpm:latest

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Build images
        run: docker build -t $PHP_IMAGE -f ./8.4-fpm/Dockerfile .
      - name: Push images
        run: docker push $PHP_IMAGE

Podsumowanie

Budowanie własnych obrazów Docker dla aplikacji PHP oferuje znaczące korzyści w zakresie standaryzacji, efektywności i kontroli. Automatyzując proces budowania i publikacji za pomocą GitHub Actions, możesz zapewnić, że Twoje obrazy są zawsze aktualne i łatwo dostępne dla projektów i potoków CI/CD.

Własne obrazy to potężne narzędzie w arsenale DevOps, umożliwiające standaryzację środowiska PHP w środowiskach deweloperskich, testowych i produkcyjnych, jednocześnie zachowując elastyczność dostosowania do konkretnych wymagań aplikacji.

Kod źródłowy

Śledź mnie na LinkedIn, aby otrzymywać więcej wskazówek o DevOps i Laravel!

Czy chciałbyś dowiedzieć się więcej o Dockerze, PHP lub CI/CD? Daj znać w komentarzach poniżej!