Deploying a Secure Laravel Application Using Docker and Kubernetes

In today’s fast-paced development landscape, deploying applications securely and efficiently is crucial. Laravel, a robust PHP framework, has gained immense popularity among developers for its elegant syntax and powerful features. When combined with Docker and Kubernetes, you can create a scalable and secure deployment environment. This article will guide you through deploying a secure Laravel application using Docker and Kubernetes, providing you with step-by-step instructions, code snippets, and actionable insights.

Understanding the Basics

What is Docker?

Docker is a platform for developing, shipping, and running applications in containers. Containers are lightweight, portable, and encapsulated environments that allow you to bundle your application with all its dependencies. This ensures that your application runs consistently across different environments.

What is Kubernetes?

Kubernetes (often abbreviated as K8s) is an open-source orchestration system for automating the deployment, scaling, and management of containerized applications. It helps manage multiple containers across a cluster of machines, ensuring high availability and load balancing.

Use Cases for Docker and Kubernetes

• Microservices Architecture: Deploying applications as microservices allows for independent scaling and updates.
• Consistent Development Environments: Developers can replicate production environments locally using Docker.
• Scalable Applications: Kubernetes manages scaling automatically based on traffic and resource usage.

Setting Up Your Laravel Application

Before diving into Docker and Kubernetes, ensure you have a Laravel application ready. If you don’t have one, you can create a new Laravel project by running:

composer create-project --prefer-dist laravel/laravel my-laravel-app

Step 1: Create a Dockerfile

The first step is to create a Dockerfile to define your application’s environment. In your Laravel project root, create a file named Dockerfile:

# Use the official PHP image
FROM php:8.1-fpm

# Set the working directory
WORKDIR /var/www

# Install system dependencies
RUN apt-get update && apt-get install -y libpng-dev libjpeg-dev libfreetype6-dev unzip git

# Install PHP extensions
RUN docker-php-ext-configure gd --with-freetype --with-jpeg
RUN docker-php-ext-install gd pdo pdo_mysql

# Copy the application files
COPY . .

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

# Install application dependencies
RUN composer install

# Set permissions
RUN chown -R www-data:www-data /var/www/storage /var/www/bootstrap/cache

Step 2: Create a Docker Compose File

Next, create a docker-compose.yml file in the root of your project. This file will define the services, networks, and volumes used in your application.

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: my-laravel-app
    container_name: my-laravel-app
    volumes:
      - ./:/var/www
    ports:
      - "8000:80"
    depends_on:
      - db

  db:
    image: mysql:5.7
    container_name: mysql
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: secret
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

Step 3: Build and Run Your Docker Containers

Run the following command to build and run your Docker containers:

docker-compose up -d

This command will start your Laravel application and the MySQL database in the background.

Securing Your Laravel Application

Environment Variables

Ensure sensitive information is stored in your .env file. Never hardcode sensitive credentials in your codebase. In docker-compose.yml, you can add environment variables for your database:

environment:
  MYSQL_DATABASE: laravel
  MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}

HTTPS Configuration

To secure your application with HTTPS, consider using a reverse proxy like Nginx in your Docker setup, or use tools like Certbot to generate SSL certificates.

Deploying on Kubernetes

Now that you have your Dockerized Laravel application, let’s deploy it on Kubernetes.

Step 1: Create a Kubernetes Deployment

Create a file named deployment.yml. This file will define your application deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: laravel-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: laravel
  template:
    metadata:
      labels:
        app: laravel
    spec:
      containers:
      - name: laravel
        image: my-laravel-app:latest
        ports:
        - containerPort: 80
        env:
        - name: DB_HOST
          value: "mysql"
        - name: DB_DATABASE
          value: "laravel"
        - name: DB_USERNAME
          value: "root"
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: password

Step 2: Create a Kubernetes Service

Next, create a service to expose your application. Create a file named service.yml:

apiVersion: v1
kind: Service
metadata:
  name: laravel-service
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 80
  selector:
    app: laravel

Step 3: Apply the Configuration

Run the following commands to deploy your application on Kubernetes:

kubectl apply -f deployment.yml
kubectl apply -f service.yml

Step 4: Access Your Application

Once deployed, you can access your Laravel application through the external IP assigned to your service. Use the command below to get the service details:

kubectl get services

Conclusion

Deploying a secure Laravel application using Docker and Kubernetes not only enhances your app's scalability and reliability but also simplifies the management of your development and production environments. By following the steps outlined in this article, you can ensure that your application is secure, efficient, and ready for production.

Remember to continuously monitor your application, keep your dependencies updated, and follow best practices in security to protect your application in the ever-evolving digital landscape. Happy coding!