Deployment und DevOps in Symfony

Die Bereitstellung von Anwendungen in einer Produktionsumgebung ist ein entscheidender Schritt im Softwareentwicklungsprozess. Symfony bietet eine Reihe von Tools und Best Practices, um sicherzustellen, dass Ihre Anwendung stabil, sicher und effizient läuft. In diesem Artikel werden wir die folgenden Themen ausführlich behandeln:

Vorbereitung Ihrer Anwendung für die Produktion
Umgebungskonfigurationen und Parameter
Bereitstellung in verschiedenen Umgebungen (Shared Hosting, VPS, Cloud Services)
Verwendung von Docker und Containerisierung
Continuous Integration/Continuous Deployment (CI/CD) Pipelines

1. Vorbereitung Ihrer Anwendung für die Produktion

1.1 Warum Vorbereitung wichtig ist

Eine Anwendung, die in der Entwicklungsumgebung funktioniert, ist nicht automatisch bereit für die Produktion. Es gibt mehrere Faktoren, die berücksichtigt werden müssen:

Sicherheit: Entfernen von Debug-Tools und Sicherstellen, dass sensible Daten geschützt sind.
Performance: Optimieren der Anwendung für Geschwindigkeit und Effizienz.
Stabilität: Sicherstellen, dass die Anwendung robust und fehlertolerant ist.

1.2 Deaktivieren des Debug-Modus

In der Produktionsumgebung sollte der Debug-Modus deaktiviert sein, um Leistungsverbesserungen zu erzielen und sensible Informationen zu schützen.

In public/index.php sicherstellen:

// public/index.php

$kernel = new Kernel($_SERVER['APP_ENV'], (bool) $_SERVER['APP_DEBUG']);

In der .env-Datei:

APP_ENV=prod
APP_DEBUG=0

1.3 Optimierung des Autoloadings

Verwenden Sie den optimierten Autoloader von Composer, um die Autoloading-Performance zu verbessern.

composer install --optimize-autoloader --no-dev

--optimize-autoloader: Generiert eine optimierte classmap für schnelleres Autoloading.
--no-dev: Installiert nur Produktionsabhängigkeiten, keine Entwicklungsabhängigkeiten.

1.4 Caching von Konfiguration und Routen

Symfony bietet Befehle, um Konfigurationen und Routen zu cachen, was die Anwendungsleistung verbessert.

Konfiguration cachen:

php bin/console cache:clear --env=prod --no-debug
php bin/console cache:warmup --env=prod --no-debug

1.5 Assets in der Produktion

Stellen Sie sicher, dass Ihre Assets (CSS, JavaScript, Bilder) für die Produktion optimiert sind.

Webpack Encore: Verwenden Sie npm run build für die Produktionsversion.
Asset-Versionierung: Aktivieren Sie die Versionierung, um Cache-Busting zu ermöglichen.

1.6 Sicherheitsprüfungen

Führen Sie Sicherheitsprüfungen durch, um bekannte Sicherheitslücken in Ihren Abhängigkeiten zu identifizieren.

composer audit

2. Umgebungskonfigurationen und Parameter

2.1 Verwendung von Umgebungsvariablen

Symfony verwendet Umgebungsvariablen, um die Anwendungskonfiguration je nach Umgebung zu steuern.

In der .env-Datei:

DATABASE_URL=mysql://db_user:db_password@127.0.0.1:3306/db_name
APP_SECRET=your_secret_key

2.2 Produktionskonfigurationen

Erstellen Sie eine .env.prod-Datei für Produktionsspezifische Einstellungen.

Beispiel .env.prod:

APP_ENV=prod
APP_DEBUG=0
DATABASE_URL=mysql://prod_user:prod_password@prod_host:3306/prod_db
APP_SECRET=your_production_secret_key

2.3 Laden von Umgebungsvariablen

Verwenden Sie die DotEnv-Komponente, um Umgebungsvariablen zu laden. In der Produktionsumgebung sollten Umgebungsvariablen direkt vom Server gesetzt werden.

2.4 Verwendung von Parameter-Dateien

Sie können auch Parameterdateien verwenden, um Konfigurationen zu speichern.

Erstellen von config/services.yaml:

parameters:
    locale: 'de'
    app.timezone: 'Europe/Berlin'

2.5 Sensible Daten schützen

Stellen Sie sicher, dass sensible Daten wie API-Schlüssel und Passwörter nicht im Quellcode oder in öffentlichen Repositories gespeichert werden.

Verwenden Sie Umgebungsvariablen oder
Einbinden von Geheimnissen mit Symfony Secrets

2.6 Symfony Secrets

Symfony bietet ein Tool namens Symfony Secrets, um sensible Informationen sicher zu speichern.

Schritt 1: Initialisieren von Secrets

php bin/console secrets:set --env=prod

Schritt 2: Hinzufügen eines Secrets

php bin/console secrets:set DATABASE_URL --env=prod

Schritt 3: Verwenden von Secrets

In Ihrer .env-Datei:

DATABASE_URL=%env(DATABASE_URL)%

3. Bereitstellung in verschiedenen Umgebungen

3.1 Shared Hosting

Einschränkungen:

Kein Zugriff auf die Serverkonfiguration.
Begrenzte Kontrolle über die PHP-Version und Erweiterungen.

Schritte zur Bereitstellung:

Dateien hochladen:
- Laden Sie den Inhalt des public/-Verzeichnisses in das Webroot-Verzeichnis Ihres Hostings hoch.
- Laden Sie den Rest der Anwendung außerhalb des Webroots hoch, falls möglich.
Anpassen von public/index.php:
Stellen Sie sicher, dass die Pfade korrekt sind, abhängig von der Serverstruktur.
Composer-Abhängigkeiten:
- Wenn composer auf dem Server verfügbar ist, führen Sie composer install aus.
- Andernfalls installieren Sie die Abhängigkeiten lokal und laden Sie den vendor/-Ordner hoch.
Dateiberechtigungen:
Stellen Sie sicher, dass die Verzeichnisse var/cache und var/log beschreibbar sind.

3.2 Virtual Private Server (VPS)

Mit einem VPS haben Sie mehr Kontrolle über die Serverumgebung.

Schritte zur Bereitstellung:

Server einrichten:
- Installieren Sie einen Webserver (Apache, Nginx).
- Installieren Sie PHP und die benötigten Erweiterungen.
- Installieren Sie eine Datenbank (MySQL, PostgreSQL).
Konfigurieren des Webservers:
- Erstellen Sie eine Virtual Host-Konfiguration.
- Weisen Sie das Webroot-Verzeichnis auf public/ zu.

Beispiel Nginx-Konfiguration:

server {
    listen 80;
    server_name example.com;
    root /var/www/my_project/public;

    location / {
        try_files $uri /index.php$is_args$args;
    }

    location ~ \.php$ {
        include fastcgi_params;
        fastcgi_pass unix:/var/run/php/php8.0-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        fastcgi_param DOCUMENT_ROOT $realpath_root;
    }
}

SSL-Zertifikate:
- Verwenden Sie Let's Encrypt für kostenlose SSL-Zertifikate.
- Installieren Sie Certbot und konfigurieren Sie HTTPS.
Deployment-Tools:
- Verwenden Sie SSH und Git, um den Code zu übertragen.
- Automatisieren Sie den Deployment-Prozess mit Skripten oder Tools wie Deployer.

3.3 Cloud Services

Cloud-Plattformen wie AWS, Google Cloud, Azure, Heroku und Platform.sh bieten spezialisierte Dienste für die Bereitstellung von Anwendungen.

Beispiel: Deployment auf Heroku

Heroku CLI installieren

curl https://cli-assets.heroku.com/install.sh | sh

Anmeldung bei Heroku

heroku login

Erstellen einer neuen Heroku-App

heroku create my-symfony-app

Heroku Buildpacks hinzufügen

heroku buildpacks:set heroku/php

Code pushen

git push heroku main

Hinweis: Stellen Sie sicher, dass Ihre composer.json die richtigen Abhängigkeiten und Skripte enthält.

4. Verwendung von Docker und Containerisierung

4.1 Was ist Docker?

Docker ist eine Containerisierungsplattform, die es ermöglicht, Anwendungen und ihre Abhängigkeiten in Containern zu isolieren.

4.2 Vorteile der Verwendung von Docker

Konsistente Umgebungen: Entwickler und Produktion verwenden die gleiche Umgebung.
Einfache Skalierung: Container können leicht skaliert werden.
Isolation: Anwendungen laufen isoliert voneinander.

4.3 Erstellen eines Docker-Setups für Symfony

Schritt 1: Docker installieren

Installieren Sie Docker und Docker Compose auf Ihrem System.

Schritt 2: Erstellen einer `Dockerfile`

# Dockerfile

FROM php:8.0-fpm

# Installieren von Systemabhängigkeiten
RUN apt-get update && apt-get install -y \
    git \
    unzip \
    libpq-dev \
    libonig-dev \
    libzip-dev \
    && docker-php-ext-install pdo pdo_mysql

# Composer installieren
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Arbeitsverzeichnis
WORKDIR /var/www

# Abhängigkeiten installieren
COPY composer.json composer.lock ./
RUN composer install --no-scripts --no-autoloader

# Anwendung kopieren
COPY . .

# Autoloader generieren
RUN composer dump-autoload --optimize

# Cache aufwärmen
RUN php bin/console cache:warmup

# Berechtigungen setzen
RUN chown -R www-data:www-data /var/www

# Exponieren des Ports
EXPOSE 9000

CMD ["php-fpm"]

Schritt 3: Erstellen einer `docker-compose.yml`

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: my-symfony-app
    container_name: symfony_app
    restart: unless-stopped
    working_dir: /var/www
    volumes:
      - ./:/var/www
    networks:
      - symfony

  webserver:
    image: nginx:alpine
    container_name: symfony_webserver
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./public:/var/www/public
      - ./docker/nginx/conf.d:/etc/nginx/conf.d
    depends_on:
      - app
    networks:
      - symfony

  db:
    image: mysql:5.7
    container_name: symfony_db
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: symfony
      MYSQL_USER: symfony
      MYSQL_PASSWORD: symfony
    ports:
      - "3306:3306"
    networks:
      - symfony

networks:
  symfony:
    driver: bridge

Schritt 4: Nginx-Konfiguration erstellen

Datei: docker/nginx/conf.d/default.conf

server {
    listen 80;
    server_name localhost;
    root /var/www/public;

    location / {
        try_files $uri /index.php$is_args$args;
    }

    location ~ \.php$ {
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        fastcgi_param DOCUMENT_ROOT $realpath_root;
    }
}

Schritt 5: Anwendung starten

docker-compose up -d

4.4 Entwicklung mit Docker

Volumes verwenden: Synchronisieren Sie den Quellcode zwischen dem Host und dem Container.
Docker Compose: Verwenden Sie Docker Compose, um mehrere Container zu orchestrieren.

4.5 Docker in der Produktion

Optimieren Sie Ihre Images: Verwenden Sie schlanke Basis-Images wie alpine.
Multi-Stage Builds: Trennen Sie Build- und Runtime-Schichten, um kleinere Images zu erzeugen.

Beispiel eines Multi-Stage Builds:

# Stage 1: Build
FROM composer:latest AS build

WORKDIR /app
COPY . /app
RUN composer install --no-dev --optimize-autoloader

# Stage 2: Runtime
FROM php:8.0-fpm-alpine

COPY --from=build /app /var/www

WORKDIR /var/www

CMD ["php-fpm"]

5. Continuous Integration/Continuous Deployment (CI/CD) Pipelines

5.1 Was ist CI/CD?

Continuous Integration (CI): Automatisiertes Testen und Überprüfen von Code, sobald er in das Repository eingecheckt wird.
Continuous Deployment (CD): Automatisiertes Ausliefern von Codeänderungen in die Produktionsumgebung.

5.2 Vorteile von CI/CD

Schnellere Entwicklungszyklen
Frühzeitige Erkennung von Fehlern
Automatisierung von wiederholbaren Aufgaben

5.3 Einrichtung einer CI/CD-Pipeline

Es gibt mehrere Tools und Plattformen, die CI/CD unterstützen, z. B. GitHub Actions, GitLab CI/CD, Jenkins, CircleCI, Travis CI.

5.4 Beispiel mit GitHub Actions

Schritt 1: Workflow-Datei erstellen

Datei: .github/workflows/ci.yml

name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:

    runs-on: ubuntu-latest

    services:
      mysql:
        image: mysql:5.7
        env:
          MYSQL_ROOT_PASSWORD: root
          MYSQL_DATABASE: symfony
        ports:
          - 3306:3306
        options: >-
          --health-cmd="mysqladmin ping --silent"
          --health-interval=10s
          --health-timeout=5s
          --health-retries=3

    steps:
    - uses: actions/checkout@v2

    - name: Set up PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: '8.0'
        extensions: mbstring, intl, pdo_mysql
        ini-values: date.timezone=Europe/Berlin

    - name: Install dependencies
      run: composer install --prefer-dist --no-progress --no-suggest

    - name: Create database
      run: php bin/console doctrine:database:create --env=test

    - name: Run migrations
      run: php bin/console doctrine:migrations:migrate --no-interaction --env=test

    - name: Run tests
      run: php bin/phpunit

Schritt 2: Erklärung der Schritte

Checkout: Klont das Repository.
PHP einrichten: Installiert die benötigte PHP-Version und Erweiterungen.
Abhängigkeiten installieren: Führt composer install aus.
Datenbank einrichten: Erstellt die Datenbank und führt Migrationen aus.
Tests ausführen: Führt PHPUnit-Tests aus.

5.5 Deployment mit GitHub Actions

Sie können auch Deployment-Schritte hinzufügen.

Beispiel:

- name: Deploy to Production
  if: github.ref == 'refs/heads/main'
  run: |
    ssh user@yourserver.com 'cd /var/www/my_project && git pull && composer install --no-dev --optimize-autoloader'

5.6 Sicherheitsaspekte

Verwenden Sie Geheimnisse: Speichern Sie Passwörter und Schlüssel in den Geheimnis-Verwaltungen der CI/CD-Plattform.
Einschränken von Berechtigungen: Stellen Sie sicher, dass nur autorisierte Personen Änderungen am Deployment vornehmen können.

Zusammenfassung

Vorbereitung für die Produktion: Optimieren Sie Ihre Anwendung durch Deaktivierung des Debug-Modus, Caching und Sicherheitsprüfungen.
Umgebungskonfigurationen: Verwenden Sie Umgebungsvariablen und Parameter, um Ihre Anwendung flexibel zu konfigurieren.
Bereitstellung in verschiedenen Umgebungen: Passen Sie Ihre Deployment-Strategie an die jeweilige Umgebung an, sei es Shared Hosting, VPS oder Cloud.
Docker und Containerisierung: Nutzen Sie Docker, um konsistente und skalierbare Umgebungen zu erstellen.
CI/CD-Pipelines: Automatisieren Sie Build-, Test- und Deployment-Prozesse, um Effizienz und Qualität zu steigern.

Weiterführende Ressourcen

How to Deploy a Symfony Application

Using Docker with Symfony

Configuring Symfony