DEV Community: Richard Spindler

Get a Legacy PHP (5.3) application running in Docker

Richard Spindler — Wed, 27 Apr 2022 09:24:00 +0000

In this article I use docker-compose to create a MySQL+PHP environment to run a Legacy application.

A Legacy application is an app that needs an old and outdated version of PHP to work.

Official images for PHP are available from Docker hub here: https://hub.docker.com/_/php/

I use the oldest image available from there:

php:5.3.29-apache

You can download the image right away with:

$ docker pull php:5.3.29-apache

For the sake of example I provide a small snippet of PHP code, that only works with older PHP versions.

index.php:

<?php
$conn = mysql_connect("localhost", "user", "saxud3sldnb");
mysql_select_db( "application_db");
mysql_close($conn);

mysql_connect is no longer available in recent PHP versions

To keep track of the docker configurations and settings create a docker-compose.yml.

Because then I can commit the docker-compose.yml into the repository and keep track of the steps required to set up the environment.

The following file is the starting version:

docker-compose.yml:

version: '3.7'
services:
  legacy-php:
    image: php:5.3.29-apache
    volumes:
    - .:/var/www/html

Then try to run it:

$ docker-compose run -T legacy-php php /var/www/html/index.php
Creating example-legacy-php-app_legacy-php_run ... done

Warning: mysql_connect(): Can't connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock' (2) in /var/www/html/index.php on line 2

Warning: mysql_select_db(): Can't connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock' (2) in /var/www/html/index.php on line 3

Warning: mysql_select_db(): A link to the server could not be established in /var/www/html/index.php on line 3

Warning: mysql_close() expects parameter 1 to be resource, boolean given in /var/www/html/index.php on line 4

There are some errors, because the MySQL server is not yet set up and connected.

This is the next step.

MySQL Docker images are available here:
https://hub.docker.com/r/mysql/mysql-server/

I am using version 5.7.37 in this guide:

$ docker pull mysql/mysql-server:5.7.37

Let's add the image to the docker-compose.yml file:

docker-compose.yml:

version: '3.7'
services:
  mysql:
    image: mysql/mysql-server:5.7.37
    environment:
     MYSQL_DATABASE: application_db
     MYSQL_USER: user
     MYSQL_PASSWORD: saxud3sldnb
    restart: always
  legacy-php:
    depends_on:
     - mysql
    image: php:5.3.29-apache
    volumes:
    - .:/var/www/html

The PHP example script requires a small change:

Use hostname "mysql" instead of "localhost".

index.php:

<?php
$conn = mysql_connect("mysql", "user", "saxud3sldnb"); <1>
mysql_select_db( "application_db");
mysql_close($conn);

Run this with the same commandline as above, and get an empty output.

The script does not do much yet.

$ docker-compose run -T legacy-php php /var/www/html/index.php  
Creating example-legacy-php-app_legacy-php_run ... done
$

So lets query the database for existing users.

index.php:

<?php
$conn = mysql_connect("mysql", "user", "saxud3sldnb"); <1>
mysql_select_db( "application_db");
$result = mysql_query("SELECT * FROM `users`");
if (!$result) {
        echo "Error: " . mysql_error();
} else {
        while ($row = mysql_fetch_assoc($result)) {
                foreach($row as $key => $value) {
                        echo $key.": ".$value.", ";
                }
        }
}
mysql_close($conn);

Running this example gives an error message, because the database is empty, and the table cannot be found.

$ docker-compose run -T legacy-php php /var/www/html/index.php 
Creating example-legacy-php-app_legacy-php_run ... done
Error: Table 'application_db.users' doesn't exist%
$

Let's initializing the database with a simple example, to
get the code working.

init.sql:

CREATE TABLE `users`(
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(80) NOT NULL DEFAULT '',
  `password` varchar(40) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`)
);
INSERT INTO `users`(`name`,`password`) VALUES ('admin', MD5('passw0rd'));

The sql script above creates an initial table, and an admin user, with a md5 encoded password.

Using pure md5 is a bad algorithm for passwords, it is used here just for the example.

The MySQL docker images have a script to initialize the database, lets add init.sql to the correct place:

docker-compose.yml:

version: '3.7'
services:
  mysql:
    image: mysql/mysql-server:5.7.37
    environment:
     MYSQL_DATABASE: application_db
     MYSQL_USER: user
     MYSQL_PASSWORD: saxud3sldnb
    restart: always
    volumes:
     - ./init.sql:/docker-entrypoint-initdb.d/init.sql
  legacy-php:
    depends_on:
     - mysql
    image: php:5.3.29-apache
    volumes:
     - .:/var/www/html
    ports:
     - "8002:80"

Port 80 is forwarded to the local machine, test the application at http://localhost:8002 from a webbrowser.

Restart the MySQL container to run the new init script.

Then run the example again:

$ docker-compose stop
Stopping example-legacy-php-app_mysql_1 ... done
$ docker-compose run -T legacy-php php /var/www/html/index.php 
Creating example-legacy-php-app_legacy-php_run ... done
id: 1, name: admin, password: bed128365216c019988915ed3add75fb%
$

And this concludes the article.

What was done:

A Docker container to run PHP 5 specific code
A MySQL container connected to the PHP container
The database is initialized and ready for use.
Open the application from a webbrowser

This article was extracted from a small eBook I wrote and published for Free as a PDF here: https://php5to8.tk

Enjoy 😸

Howto use Docker Agent in a Jenkinsfile Matrix Build

Richard Spindler — Tue, 06 Jul 2021 07:04:35 +0000

There is one simple tutorial that I was looking for on the web, and I could not find it.

So I wrote it myself.

Jenkins has matrix builds, and Jenkins has agent docker for builds inside a docker image.

Combined, these features make it easy to test a project with multiple versions of PHP for example.

So here is the simple example I came up with: Put this in your Jenkinsfile and you are done.

pipeline {
    agent none
    stages {
        stage('Test') {
            matrix {
                agent {
                    docker { image "${DOCKER_IMAGE}" }
                }
                axes {
                    axis {
                        name 'DOCKER_IMAGE'
                        values 'php:5.3', 'php:5.6'
                    }
                }
                stages {
                    stage('Test') {
                        steps {
                            sh 'php --version'
                        }
                    }
                }
            }
        }
    }
}

Please let me know if it helps you 😊

Learning more

Testing your software in different environments is a best practice for software engineering.

If you like this article: I am writing a book about best practices for legacy code projects:

Leading a Legacy Software Team

How to keep a Dockerfile updated with Dependabot

Richard Spindler — Wed, 16 Jun 2021 09:45:37 +0000

Dependabot used to be a separate service that scanned your github repository for outdated dependencies in 3rd party packages and libraries.

This service was acquired by Github and is now integrated into the platform.

It is a free service, and a great way to keep your projects dependencies up to date.

Dependabot will automatically create a pull request to your project to bump any outdated dependencies to the latest version.

As an example project I am using a simple "Hello World" style PHP script that runs in the standard PHP Docker image. And Dependabot will bring the outdated PHP version up to date with.

To verify that the application is compatible with the updated version of PHP a Github actions workflow will run the code with the Dockerfile.

So here is what you will learn:

Create a Dockerfile and hello.php as the application
Create a Github Actions workflow to run the above code in Docker
Enable Dependabot for Docker

Dockerfile

This is the simplest Dockerfile for running a PHP script. The current stable version of PHP is 8.0.7 but I am using a slightly outdated version number. I want to see Dependabot taking action on this outdated version.



FROM php:8.0.0

Note: Rather than using a specific version I could use the Docker tag latest to always have the latest version. But this is considered a bad practice.

Before upgrading to the latest version of a dependency, you must run your applications tests.

Without a specific version in the Dockerfile you cannot run an automated test suite before the upgrade.

hello.php

This Hello World will not actually print the string "Hello World", but instead the current PHP version number. Therefore the logs of the actions workflow show if the PHP version has been updated correctly and that the correct Dockerfile was used.



<?
echo phpversion();
?>

.github/workflows/php.yml

This is a very basic actions workflow that runs on the main branch and also on any pull requests that are made for the main branch.

Github recently updated the default branch name from master to using main. So if you have an older repository, you must change this example to work with the old convention.



name: PHP CI
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Build docker images
      run: docker build -t local - < Dockerfile
    - name: Run tests
      run: docker run -t -v $PWD:/srv -w/srv local php hello.php

This builds the Dockerfile and runs the code in hello.php inside that image.

.github/dependabot.yml

To enable Dependabot you must go to "Insights" on your repository main page.

The setting for Dependabot is hidden under "Dependency Graph":

You can use the default configuration file that is suggested by Github. Just add "docker" to "package-ecosystem", Dependabot will find your Dockerfile automatically.

For me the dependabot.yml looks like this:



version: 2

updates:


package-ecosystem: "docker"
directory: "/"
schedule:
  interval: "daily"

Waiting for a pull request

Now Dependabot is set up and ready to go. It will check your Dockerfile daily, and creates a pull request to upgrade to the latest stable release of PHP.

And the pull request is verified by the Github actions workflow that I created above.

For me the diff from the commit by the Dependabot looks like this:

Learning more

Keeping your dependencies up to date is a best practice for software engineering.

If you like this article: I am writing a book about best practices for legacy code projects:

Leading a Legacy Software Team