A couple of days ago, I found myself with some spare time, and two specific actions came to my mind regarding my website. First, I wanted to migrate it to a different virtual machine, and secondly, I aimed to enhance the overall theme and user interface.

Considering that I didn’t want to experiment directly on the production environment, I decided to explore the world of WordPress on my local machine. However, I had one condition:Installing the least number of tools is my first condition. Instead, I opted to leverage Docker for testing purposes. In this article, I will guide you through the process of achieving this without the need for any external installations.

Docker

Docker is a platform that allows you to package and run applications in isolated environments called containers. It provides a lightweight and efficient way to deploy software, as containers are self-contained and can run consistently across different systems. Docker simplifies the process of managing dependencies and ensures that applications run smoothly in any environment, making it popular for software development, deployment, and scaling.

In order to install docker you can download from the official website : https://www.docker.com/

Now , what we want to have is wordpress + mysql toghther  , in order to have that we need to create a docker compose file , but first what is docker compose ?

Docker Compose is a tool that allows you to define and manage multi-container applications. It is used to specify the services, networks, and volumes required for your application’s containers to work together. With Docker Compose, you can describe your application’s infrastructure in a YAML file, including details like container images, environment variables, networking configurations, and dependencies between containers. By using Docker Compose, you can easily spin up and manage complex applications with multiple containers, simplifying the process of running and orchestrating your application’s various components.

So , in our project we are going to need to have two containers , one for my sql and oen for wordpress .

Docker compose File

version: '3'

services:
  db:
    image: mysql:latest

    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress

  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    ports:
      - 3000:80
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress

The provided YAML file is a Docker Compose file that defines the configuration for a multi-container application. Let’s break down the role of each section within this file:

1. `version: ‘3’`: Specifies the version of the Docker Compose file format being used. In this case, it is version 3.

2. `services`: This section defines the individual services (containers) .

a. `db`: This service represents a MySQL database container.
– `image: mysql:latest`: Specifies the Docker image to use for the MySQL container, in this case, the latest version.
– `volumes`: Mounts a Docker volume named `db_data` to the container’s `/var/lib/mysql` directory. This allows data to persist even if the container is recreated.
– `restart: always`: Specifies that the container should be automatically restarted if it stops.
– `environment`: Sets environment variables within the container. Here, it defines the root password, database name, user, and password for MySQL.

b. `wordpress`: This service represents a WordPress container.
– `depends_on`: Specifies that the WordPress container depends on the `db` service, ensuring that the database container is started before the WordPress container.
– `image: wordpress:latest`: Specifies the Docker image to use for the WordPress container, using the latest version.
– `ports`: Maps port 80 of the container to port 3000 on the host system, allowing access to the WordPress application.
– `restart: always`: Indicates that the container should be automatically restarted if it stops.
– `environment`: Sets environment variables within the container. Here, it configures the WordPress container to connect to the MySQL container using the specified host, user, password, and database name.

Overall, this Docker Compose file defines two services: a MySQL database container (`db`) and a WordPress container (`wordpress`). The configuration ensures that the WordPress container can communicate with the MySQL container, allowing you to run a WordPress application with a MySQL database using Docker.

In order to test we can use the following command :

docker-compose up -d

The command `docker-compose up -d` is used to start the services defined in the Docker Compose file in detached mode.

Here’s a breakdown of the command:

– `docker-compose`: Refers to the Docker Compose command-line interface.
– `up`: Specifies that you want to start the defined services.
– `-d`: Stands for “detached” mode, which means the services will run in the background, and the terminal will be available for other commands.

When you run `docker-compose up -d`, Docker Compose reads the configuration from the `docker-compose.yml` file in the current directory and starts the associated containers as defined in the file. The services will be started in the background, and you will see the container names or IDs printed to the console.

Using the `-d` flag allows you to start the services and continue using the terminal for other tasks without being attached to the containers’ logs or output.

after runing the command we can see the below containers up and runing
and if we visit http://localhost:3000/
now we need to just follow the steps to install it .

Taking a backup from the official website

There are several methods available for taking backups and managing them within WordPress. However, based on my limited expertise with WordPress, I highly recommend using the “All-in-One WP Migration” plugin, which can be found at https://servmask.com/.

The “All-in-One WP Migration” plugin offers a comprehensive solution for handling backups within WordPress. It simplifies the process of creating backups, allowing you to effortlessly migrate your website from one location to another. With this plugin, you can easily export your entire WordPress installation, including the database, media files, themes, plugins, and more, into a single file. This file can then be imported into a different WordPress installation, making it an efficient and convenient tool for website backups and migrations.

By utilizing the “All-in-One WP Migration” plugin, you can ensure the safety and security of your WordPress website, making it easier to restore or move your site when needed.

now when I click that ,a file with .wpress extension will be downloaded and you need to install the same one on the local version in order to import it .

Importing the backup on the local environment

Now let’s follow the below step in order to import our file :

This problem that we have is because wordpress have limit to upload maximum of 2 MB file and in my case it was 700 MB , let’s modify our docker compose file in order to modify the uploads ini file rules .

first , let’s modify our yaml file :

version: '3'

services:
  db:
    image: mysql:latest
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress

  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    ports:
      - 3000:80
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./uploads.ini:/usr/local/etc/php/conf.d/uploads.ini
      - ./uploads:/var/www/html/wp-content/uploads
volumes:
  db_data:
  uploads:

and in the same directory let’s create the uploads.ini file that will replace the original one

file_uploads = On
memory_limit = 1024M
upload_max_filesize = 1024M
post_max_size = 1024M
max_execution_time = 600

The provided `upload.ini` file contains configuration settings for handling file uploads in a WordPress environment. Let’s break down each directive and its purpose:

1. `file_uploads = On`: This directive enables file uploads on the server. It ensures that the server allows files to be uploaded through PHP scripts.

2. `memory_limit = 1024M`: This directive sets the maximum amount of memory that PHP can allocate for script execution. In this case, it is set to 1024 megabytes (1 gigabyte), allowing PHP to utilize more memory if necessary during file uploads.

3. `upload_max_filesize = 1024M`: This directive determines the maximum size of an individual file that can be uploaded. Here, it is set to 1024 megabytes (1 gigabyte), meaning files of up to this size can be uploaded.

4. `post_max_size = 1024M`: This directive specifies the maximum size of the entire HTTP POST request, which includes all form data, including uploaded files. It is set to 1024 megabytes (1 gigabyte), ensuring that the total request size, including uploaded files, can be as large as this limit.

5. `max_execution_time = 600`: This directive defines the maximum execution time, in seconds, for PHP scripts. It is set to 600 seconds (10 minutes), allowing more time for the server to process file uploads that may take longer.

By configuring the `upload.ini` file with these settings, you are adjusting various parameters related to file uploads in WordPress. These settings allow larger file uploads, increase memory allocation, and provide more execution time for processing uploads, ensuring a smoother experience when handling large files or performing bulk uploads in WordPress.

Now we need to edit remove the old volume from docker and run our command again and login to our website :
Now our website is being imported on local machine and we can run tests .

Hope this was helpful .

First of all and before we go straight to deployment and demo let’s understand what is a reverse proxy .

A reverse proxy intercepts all incoming requests and direct them to the appropriate server ,it can play the role of Load Balancer ” a Traffic Cop ” that will distribute the clients requests across group of servers in order to maximizes speed and capacity and making sure that no server is overloaded (in case a server is down the load balancer will redirect the traffic to the other servers ) ,more than that a reverse proxy will protect the identity of the other servers and act as a defense againsts security attacks .In this sense the reverse proxy will make sure that multiple servers can be accessed only from a single URL .

Prerequisites

• Visual studio or visual studio code
• A command mine /Terminal
• Docker installed on your system

Part 1- Without Docker Compose

in this first part we will create our dotnet application that we will use now and later too , also nginx .
and we will go straight to our Index.cshtml  , and edit it to be like this :

@page
@model IndexModel

@{
    ViewData["Title"] = "Home page";
    var hostname = ViewData["host"];
}

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
    <p>
        <strong>Hostname :</strong> <h3> <code>@hostname</code></h3>
    </p>
</div>

Also we will edit the Index.cshtml.cs 

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using System.Net;

namespace hostnameapp.Pages
{
    public class IndexModel : PageModel
    {
        private readonly ILogger<IndexModel> _logger;
        [BindProperty]
        public string? hostname { get; set; }
        public IndexModel(ILogger<IndexModel> logger)
        {
            _logger = logger;
        }

        public void OnGet()
        {
            String hostName = Dns.GetHostName();
            Console.WriteLine(hostName);
            ViewData["host"] = hostName;
            

        }
    }
}

now if we run the application using IIS express we will have this view  :
As you can see the goal here is to show the hostname , nothing special .

now we will dockeriz application by creating a dockerfile  with this content (full source code of the solution will be shared )

FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine AS base

WORKDIR /app
ENV ASPNETCORE_URLS http://+:5000
# EXPOSE 80
EXPOSE 5000

FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /src
COPY ["hostnameapp/hostnameapp.csproj", "hostnameapp/"]
RUN dotnet restore "hostnameapp/hostnameapp.csproj"
COPY . .
WORKDIR "/src/hostnameapp"
RUN dotnet build "hostnameapp.csproj" -c Release -o /app/build

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

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

now we will create the nginx application but we have some config for the app :
we will create  a file : nginx.conf

worker_processes 4;
 
events { worker_connections 1024; }
 
http {
    sendfile on;
    limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;
    # upstream app_servers {
    #     #server app:127.0.0.1:5000;
    #   # server  http://backend:5000;
    # }
 
    server {
        listen 80;
 
        location / {
            proxy_pass          http://backend:5000;
            proxy_redirect     off;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Host $server_name;
        }
    }
}

Also we are going to docke the nginx proxy app

FROM nginx:alpine
RUN rm -r  /etc/nginx/nginx.conf
COPY nginx.conf /etc/nginx/nginx.conf

now we can build both apps and run them to see what will happen .

let’s start with our dotnet application we need to build and run our solution :

docker build -t backend  .
docker run -it --rm -p 5000:5000   --name backend backend

Now if you go to your browser and visit :  http://localhost:5000/ you will have this result :

And now as you can see our hostname have the id of the container .

now it’s time to run the nginx proxy that will be the entry to our application or let’s say the way we will expose our application .

docker build -t frontend  .
docker run -it --rm -p 8082:80   --name frontend frontend

if we run those commandes the project will build but will not run and we will finish by having an error saying that host not found , the host is the backend that we defined in the config file with port 5000 , and that’s because the two containers are not in the same network !
now let’s make some changes :
Let’s create a network :

docker network create demonetwork-001;
#to inspect that network 
docker network inspect demonetwork-001;

now we need to attach our containers to the network that we have created  :

docker network connect demonetwork-001 backend;
#this will fail because the container did exit beceause of error
docker network connect demonetwork-001 frontend;

--------------instead we will use this -------------------------
docker run -it --rm -p 5000:5000 --network=demonetwork-001  --name backend backend
docker run -it --rm -p 8082:80  --network=demonetwork-001  --name frontend frontend

and like that we will have our result  while visiting our entry point on port 8082 :

Part 2- With Docker Compose

now all we need is to create a docker compose file without editing our solutions : docker-compose.yml

version: "3.9"
services:
  app:
    build: ./hostnameapp
    expose: 
      - "5000"    
  proxy:
    #image: nginx:alpine
    build: ./nginx
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app
    links:
      - app  
    ports:
      - "8082:80"

now in our file we define the two apps and we say that the proxy app depends on the first app let see the result :
and this is our goal , we want the backend not to be exposed to public and we want our frontend exposed as you can see on port 8082 and we can not acces the backend , now if we modify the config file and add different backends with different port the load balancer will play it’s role to manage the traffic between the apps .

Now if we have the same app on different port and we edit the config file like this ofr example :

worker_processes 4;
 
events { worker_connections 1024; }
 
http {
    sendfile on;
 
    upstream app_servers {
        server app:5000 weight=4;
        server app2:5010 weight=2;
    }
 
    server {
        listen 80;
 
        location / {
            proxy_pass         http://app_servers;
            proxy_redirect     off;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Host $server_name;
        }
    }
}

the result will show that we balance between the two apps

that’s it for this demo , in next post we will discuss how we will do this on Azure Kubernetes Service (AKS) .

source code : https://bit.ly/3EDJVus

In this tutorial we are going to see how to deploy a function using docker hub .

To use the commands used in powershell first you need to Install the Azure Functions Core Tools .

The script used in the video :

func init –docker

func new

code .

docker build –tag account/fucnction:v1.

docker run -p 8080:80 -it account/fucnction:v1

docker push account/fucnction:v1

Happy DevOps day =)

Today , in this new article we are going to see how to install wordpress on local machine, using xampp server from a docker image .

First step we are going to pull an image of xampp from docker hub , for that I have found this docker image , You can download it using this command from your power shell or your favorite command tool :

https://hub.docker.com/r/tomsik68/xampp/

while your pulling this image from docker hub , you can in same time , download word press from the official website the version that exist right now , while i’m writing this article is version : 5.2.2 .

After all is done , now let’s see our image and run it .

To see our image we simply type : docker images and if you have been using docker for a while , you will have a couple of images like I do in picture below .

docker

docker run –name myXampp -p 41061:22 -p 41062:80 -d -v C:\Users\Heero\Downloads\Compressed\wordpress-5.2.2\wordpress:/www tomsik68/xampp

Now let’s understand this command .

The command above will expose the SSH server on port 41061 and HTTP server on port 41062.

one thing you should do is , to replace the directory where you have downloaded wordpress, for me

C:\Users\Heero\Downloads\Compressed\wordpress-5.2.2\wordpress , so in the command you should :

docker run –name myXampp -p 41061:22 -p 41062:80 -d -v Your directory :/www tomsik68/xampp

After you run the command , by typing : docker ps you will see your working container :

To connect to your web page, visit this URL: http://localhost:41062/www

And to open up the XAMPP interface:  http://localhost:41062/

Now one more free tip , if you try to install a plugin you will get an error .

WordPress will be asking for FTP credentials on localhost and for that , there is a fix in 2 steps .

config.php

define(‘FS_METHOD’,‘direct’);

Directory

now we need to change the permission in our installation folder to “Read & Write” for everyone :

Now , you are ready to go and to use your WordPress site and start publishing your articles !

Happy WordPress day