DEV Community: Nao

[PHP] Upgrading from PHP 7.4 to 8.1🐘✨

Nao — Fri, 30 May 2025 14:30:28 +0000

Introduction

I upgraded my project’s PHP version from 7.4 to 8.1.

This article summarizes the steps I took and the considerations I encountered during the upgrade process.

What This Article Covers

Upgrading PHP from version 7.4 to 8.1.

Environment

Using EC2
- OS Image: Amazon Linux 2 Kernel 5.10
PHP Version: PHP 7.4.33 (cli)
PHPUnit Version: 9.5.28
CakePHP Version: 4.2.12
nginx: nginx/1.22.0
php-fpm: PHP 7.4.33 (fpm-fcgi)

Preparation

Gathering Upgrade Information

PHP

Each PHP version is supported for three years (2 years active support + 1 year security support).
Since support for PHP 7.4 ended on November 28, 2022, I decided to upgrade to PHP 8.1 to ensure continued maintainability.

PHP Supported Versions

First, I reviewed the official documentation for breaking changes:

PHPUnit

As I was using PHPUnit for testing code, I also checked compatibility between PHP and PHPUnit.

I checked the current PHPUnit version with the following command:

$ ./vendor/bin/phpunit --version

PHPUnit 9.5.28 by Sebastian Bergmann and contributors.

According to the PHPUnit and PHP version compatibility chart, PHPUnit 9.x supports PHP 7.3 and above.
Since I'm upgrading to PHP 8.1, our current version (9.5.28) remains compatible.

CakePHP

Next, I checked compatibility between CakePHP and PHP.

I confirmed the current CakePHP version:

$ cat ./vendor/cakephp/cakephp/VERSION.txt
...
4.2.12

Based on the CakePHP 4 System Requirements, CakePHP 4 supports PHP 7.4 and higher, including PHP 8.1. So there are no issues here either.

Preparing a Test Environment

Since the service was already deployed, I needed to verify if the upgrade would succeed and ensure functionality post-upgrade in a separate environment.

I used another EC2 instance to test the upgrade to PHP 8.1, ran the test code, confirmed stable behavior, and then proceeded with the production upgrade.

Steps to Upgrade to PHP 8.1

Back up the php.ini file (PHP configuration file).

First, locate php.ini:

$ find / -name "php.ini" -ls

8651969   64 -rw-r--r--   1 root     root        62221  Jan 21 03:18 /etc/php.ini

Create a backup:

$ cp -a /etc/php.ini /etc/php.ini.org

If you have a custom version of php.ini, back that up as well.

Check the current PHP version:

$ php -v

PHP 7.4.33 (cli) (built: Nov 19 2022 00:22:13) ( NTS )

List installed PHP packages to reinstall them later:

$ yum list installed php*

Installed Packages:
php-cli.x86_64, php-common.x86_64, php-fpm.x86_64, php-intl.x86_64, php-json.x86_64,
php-mbstring.x86_64, php-mysqlnd.x86_64, php-pdo.x86_64, php-xml.x86_64

Remove current PHP packages:

$ yum remove "php*"

Check available PHP versions via Amazon Linux Extras:

$ amazon-linux-extras list available | grep php

42 *php7.4=latest            enabled      [ =stable ]
_  php8.0                   available    [ =stable ]
_  php8.1                   available    [ =stable ]

Disable PHP 7.4:

$ amazon-linux-extras disable php7.4

Install PHP 8.1:

$ amazon-linux-extras install php8.1

Verify installed PHP packages:

$ yum list installed php*

Installed Packages:
php-cli.x86_64, php-common.x86_64, php-fpm.x86_64, php-mysqlnd.x86_64, php-pdo.x86_64

Install any missing packages:

$ yum install php-intl php-json php-mbstring php-xml

Confirm PHP version:

$ php -v

PHP 8.1.14 (cli) (built: Jan 20 2023 18:11:30) (NTS)

Restart nginx and php-fpm:

$ systemctl restart nginx php-fpm

The upgrade is complete!

Now run the test code and verify behavior through the browser.

Conclusion

Through this upgrade, I learned the importance of checking compatibility with related packages and frameworks like PHPUnit and CakePHP.

While I relied on reading documentation and running tests to identify incompatibilities, in the future, I’d like to try static analysis tools for migration checks (see: PHP8 Migration Compatibility Check).

Feel free to share your thoughts or feedback!

References

PHP 8.1 Upgrade Steps:
- Amazon Linux 2 FAQs
- Upgrading PHP on Amazon Linux

[GitHub Actions] Automate Build and Deployment of Your Python Package to PyPI and GitHub Releases 🐍📦

Nao — Sat, 10 Aug 2024 04:26:48 +0000

When releasing a custom library, it can be tedious to manually build it locally, upload it to TestPyPI for verification, then upload it to PyPI, and finally tag and release it…

So, I decided to automate the deployment using GitHub Actions.

Objective of This Article

When you push a tag to the remote repository, this setup will automatically upload your package to PyPI and create a GitHub release.

After you push a tag from your local environment…

git tag vX.X.X
git push origin vX.X.X

The following steps will be automatically executed in order:

Upload to TestPyPI
Upload to PyPI
Create a release on GitHub and distribute the source code

We will create a workflow as shown in the image below.

Steps

Preparation

Note: Instead of using setup.py as the packaging tool configuration file, we will use pyproject.toml. According to PEP-518, pyproject.toml is recommended for modern Python projects.

Prepare your Python package and upload it as a project to both PyPI and TestPyPI.

If you already have a custom library on PyPI, you can skip this step.

Follow the tutorial below to upload a sample package to TestPyPI and PyPI:

https://packaging.python.org/ja/latest/tutorials/packaging-projects/#creating-a-license

Creating a Workflow File in GitHub Actions

In your repository, go to Actions > Set up a workflow yourself > Create a YAML file with any name (in this case, main.yaml) and commit it.

It’s okay if the file is empty initially.

Setting Up Publishing in PyPI

Traditionally, to upload a package from GitHub Actions to PyPI, you would need to create an API token in PyPI and store that token as a secret in GitHub.

However, by using Publishing, you can automatically issue and authenticate a temporary token when connecting to pre-configured services (including specific users, repositories, etc.)!

Publishing is easier to set up, and since the token has a short expiration time, it also offers better security.

From your project page on PyPI, select Publishing > Add a new publisher.

Fill in the fields as shown in the image below and click Add.

Next, open TestPyPI and create a publisher in the same way.

Use a different environment name than the one used for PyPI.

Workflow in GitHub Actions

Now let’s write the workflow in the YAML file you just created.

1. Start the Workflow When a Tag is Pushed

name: Publish Python 🐍 distribution 📦 to PyPI and TestPyPI

on:
  push:
    tags:
      - 'v*.*.*'

2. Build

To build the package, pyproject.toml must exist in the repository, so make sure it is not included in .gitignore.

jobs:
  build:
    name: Build distribution 📦
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4 # Checkout the code
    - name: Set up Python
      uses: actions/setup-python@v5 # Set up the Python environment
      with:
        python-version: "3.x"
    - name: Install pypa/build # Install the build tool
      run: >-
        python3 -m
        pip install
        build
        --user
    - name: Build a binary wheel and a source tarball
      run: python3 -m build # Build the package
    - name: Store the distribution packages # Temporarily store the build artifacts in the dist directory under the name python-package-distributions
      uses: actions/upload-artifact@v4
      with:
        name: python-package-distributions
        path: dist/

3. Publish to TestPyPI

  publish-to-testpypi:
    name: Publish Python 🐍 distribution 📦 to TestPyPI
    needs:
    - build # Start the job only if the build job has completed
    runs-on: ubuntu-latest

    environment:
      name: testpypi # Enter the environment name set in the Publisher
      url: https://test.pypi.org/p/example-package-hanaosan0318 # Project URL

    permissions:
      id-token: write  # Grant Publishing permissions

    steps:
    - name: Download all the dists # Download the build artifacts that were saved earlier
      uses: actions/download-artifact@v4
      with:
        name: python-package-distributions
        path: dist/
    - name: Publish distribution 📦 to TestPyPI # Publish to TestPyPI
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
        repository-url: https://test.pypi.org/legacy/

4. Publish to PyPI

  publish-to-pypi:
    name: >-
      Publish Python 🐍 distribution 📦 to PyPI
    needs:
    - publish-to-testpypi # Start the job only if the TestPyPI publishing job has completed
    runs-on: ubuntu-latest
    environment:
      name: pypi # Enter the environment name set in the Publisher
      url: https://pypi.org/p/example-package-hanaosan0318 # Project URL
    permissions:
      id-token: write

    steps:
    - name: Download all the dists
      uses: actions/download-artifact@v4
      with:
        name: python-package-distributions
        path: dist/
    - name: Publish distribution 📦 to PyPI
      uses: pypa/gh-action-pypi-publish@release/v1

5. Create a GitHub Release

  github-release:
    name: >-
      Create GitHub Release with source code
    needs:
    - publish-to-pypi # Start the job only if the PyPI publishing job has completed
    runs-on: ubuntu-latest

    permissions:
      contents: write # Grant permission to create a GitHub release

    steps:
    - name: Checkout code
      uses: actions/checkout@v4 # Checkout the code

    - name: Create GitHub Release
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # A temporary token that is automatically generated each time the workflow is run
      run: >-
        gh release create
        '${{ github.ref_name }}'
        --repo '${{ github.repository }}'
        --notes "Release for version ${{ github.ref_name }}"

Finally, you have defined the workflow!

You can view the entire YAML file at the following link:

https://github.com/hanaosan/ci-cd-practice-python-library/blob/main/.github/workflows/main.yml

Deploying

Update the version in pyproject.toml to the release version and push the changes.

[project]
name = "example_package_hanaosan0318"
version = "2.0.3" # Change to the release version
authors = [
  { name="Example Author", email="author@example.com" },
]

Create a tag and push it.

git tag v2.0.3
git push origin v2.0.3

The package will be uploaded to PyPI and TestPyPI.

A release will also be created, and you can see the source code distributed in zip and tar.gz formats.

And that’s it!

You have now automated the process of uploading your package to PyPI and creating a release on GitHub when you push a tag to the remote repository.

References

How to connect DynamoDB with CakePHP4

Nao — Wed, 10 Jul 2024 16:08:33 +0000

Introduction

When using DynamoDB, I struggled with connecting CakePHP and DynamoDB due to outdated articles and the need to create many files. Therefore, I wrote this article as a memo.

What We'll Do in This Article

We will connect to DynamoDB using CakePHP4 and retrieve table information.

Prerequisites

Using EC2
- OS Image: Amazon Linux 2 Kernel 5.10
CakePHP Version: 4.2.12
nginx: nginx/1.22.0
PHP Version: PHP 7.4.33 (cli)
PHP-FPM: PHP 7.4.33 (fpm-fcgi)
AWS SDK for PHP Version: 3.257

Preparation on AWS Side

Creating a Table in DynamoDB

Create an appropriate table from AWS Console Home > DynamoDB > Tables > Create Table.

Installing AWS SDK

While operations with AWS were done using the web console, the AWS SDK is necessary to use various services on AWS from a program.

The AWS SDK is a development kit (a set of APIs and libraries necessary for development) provided for different programming languages to operate AWS services from a program.

This time, we'll use the AWS SDK for PHP.
Install it using composer. (Install Composer)

cd project_base_directory
composer require aws/aws-sdk-php

If the aws directory is created within /vendor, the installation is successful.

Creating an IAM Role

Like entering a password to log in from the console, authentication information is needed when accessing resources on AWS from a program.

Obtain the AWS access key as authentication information.

There are three ways to obtain the access key depending on the user type and authentication method. (Reference: Obtaining AWS Access Keys)

If accessing AWS as an IAM user, there are two ways:

Obtain the access key directly from the IAM user (long-term credentials) ← AWS not recommended
Create an IAM role and link it to the EC2 instance. Automatically obtain temporary credentials each time you access (short-term credentials)

This time, we adopted the method of sending requests to AWS using temporary credentials by utilizing an IAM role.

Create an IAM role with a policy that allows access to DynamoDB.

IAM > Roles > Create Role
Trusted Entity Type
- AWS Service
Use Case
- EC2
Permission Policy
- AmazonDynamoDBFullAccess
Role Name
- role_test

Link the created IAM role to the EC2 instance.

EC2 > Select Instance > Actions > Security > Modify IAM Role
Select role_test and "Update IAM Role"

Preparation on the PHP Side

Instantiate Client Object

To operate the database on DynamoDB, instantiate the client object (this time DynamoDB object).

The client object contains methods for executing the service's API.

To instantiate, pass the configuration options as an associative array to the constructor (a method executed when the class is generated).

Although you can directly instantiate the client object as shown below, this time, we instantiate the Sdk class → then instantiate DynamoDB.

Example:

//Create an S3Client
$s3 = new Aws\S3\S3Client([
    'version' => 'latest',
    'region' => 'us-east-2'
]);

By passing the associative array of options to the Sdk class, it can be used as a common set of configuration options for multiple clients.

This time, I used only DynamoDB, but if you want to use other AWS services like S3 at the same time, it's convenient as you don't need to write the configuration options each time.

Although only region and version values are set in the associative array of options, the access key is also referenced when the client object is generated, as the EC2 instance linked to the IAM role created earlier obtains temporary credentials.

This time, I created and described files under the plugin directory.

plugins/aws/Client/aws.php

<?php
namespace aws\Client;

use Aws;
use Aws\DynamoDb;
use Cake\Core\Configure;

/**
 * Common AWS Class
 */
class AwsClient
{
    private $_config = null;
    private $_sdk = null;
    private $_dynamodb = null;

    /**
     * Constructor
     */
    public function __construct()
    {
        $this->_sdk = new Aws\Sdk([
            'region' => 'ap-northeast-1',
            'version' => 'latest',
        ]);
    }

    /**
     * Get DynamoDB Client
     *
     * @return $this->dynamodb DynamoDbClient
     */
    public function getDynamoDbClient()
    {
        if ($this->_dynamodb === null) {
            $this->_dynamodb = $this->_sdk->createDynamoDb();
        }

        return $this->_dynamodb;
    }
}

plugins/aws/DynamoDb.php

<?php

namespace aws;

use aws\Client\AwsClient;
use Util\StrictComparison;

/**
 * DynamoDB Interface
 */
class DynamoDb
{
    private $_client = null;
    /**
     * Constructor
     *
     * @param \Aws\Client\AwsClient $awsClient AwsClient Object
     */
    public function __construct(AwsClient $awsClient = null)
    {
        if (StrictComparison::isNull($awsClient)) {
            $awsClient = new AwsClient();
        }
        $this->_client = $awsClient->getDynamoDbClient();
    }

    /**
     * Get record by key name
     * 
     * @param string $tableName Table name
     * @param array $key Primary key
     * @return object Matching record
    */
    public function getItemByKey(string $tableName, array $key)
    {
        return $this->_client->getItem([
            'Key' => $key,
            'TableName' => $tableName,
        ]);
    }
}

Retrieve Table Information

With the necessary processes to connect to DynamoDB written, finally, instantiate the DynamoDB class in the Controller and retrieve the record by the specified key value.

src/Controller/DynamoDbController.php

<?php
declare(strict_types=1);

namespace App\Controller;

use Cake\Controller\Controller;
use aws\DynamoDb;

class DynamoDbController extends Controller
{
    public $tableName = 'created_table_name';
    public $key = [
        'key_name' => [
            'S' => 'value_to_search'
        ],
    ];

    public function index()
    {
        $dynamoDb = new DynamoDb();
        $result = $dynamoDb->getItemByKey($this->tableName, $this->key);
        // Pass the value of $result to the template so that the obtained content can be used on the view side.
        $this->set(compact('result'));
    }
}

You should be able to confirm that the target record is obtained by checking the result with var_dump, etc.

Summary

Using this procedure, it seems possible to connect not only to DynamoDB but also to other AWS services.

Personally, it was very educational as I had only used Composer for loading packages, and now I know it is also necessary to use it when loading class files.

References

Creating IAM Roles
- Using temporary credentials with AWS resources
Setting Namespace
- PHP Autoload (autoload)
Instantiating Client Object
- Creating a Client
Retrieving Table Information
- Read items from a DynamoDB table using the AWS SDK