PHP: Deploy with GitHub Actions

How to deploy your PHP code using GitHub Actions

👋 Welcome to the Stackhero documentation!

Stackhero offers a ready-to-use PHP cloud solution that provides a host of benefits, including:

• Deploy your application in seconds with a simple git push.
• Use your own domain name and benefit from the automatic configuration of HTTPS certificates for enhanced security.
• Enjoy peace of mind with automatic backups, one-click updates, and straightforward, transparent, and predictable pricing.
• Get optimal performance and robust security thanks to a private and dedicated VM.

Save time and simplify your life: it only takes 5 minutes to try Stackhero's PHP cloud hosting solution!

GitHub Actions is a powerful tool that lets you automate workflows, including deploying your PHP code directly to your production servers. In this guide, we will walk through how you can securely deploy your PHP application to both staging and production environments using GitHub Actions.

The recommended approach is to maintain two branches in your repository: staging and production. Whenever you push code to these branches, it will be automatically deployed to the corresponding Stackhero instance.

Having a staging instance is not mandatory. However, using both staging and production instances is strongly recommended to ensure smooth deployments and increased confidence when deploying to production. This practice aligns with industry standards and helps prevent potential issues.

To get started, you will need a GitHub account with your PHP code hosted in a repository.

Creating the PHP services

First, log in to your Stackhero dashboard and create two PHP services, one for staging and one for production. For clarity, you may want to rename these services to "Production" and "Staging".

If you do not have a Stackhero account, you can create one for free in just two minutes and set up your PHP cloud services with a few clicks.

Example of production and staging services

Configure SSH keys

SSH keys are the recommended method for allowing GitHub Actions to securely connect to your PHP service during deployment. In this guide, you will create a unique SSH key pair just for this purpose.

Generate SSH keys

To generate new SSH keys, you can run this command on your computer:

ssh-keygen -C "" -f /tmp/ssh_key -N ""

Set the public key

Next, retrieve the public key by running:

cat /tmp/ssh_key.pub

Head over to your Stackhero dashboard and select your "Production" PHP service. Click on "Configure" and follow these steps:

1. Under SSH public keys, click on "Add a public key".
2. Set the Description to "GitHub Action".
3. Paste the public key you just retrieved into the Key field.

Get service settings

Set the private key

Now, add the private key to your GitHub project so it can be used during deployment:

• Go to Settings, then select Environments and click on New environment.

  Configuring GitHub environments

• In the Name field, enter "production" and confirm.

  Setting the environment

• Click on the No restriction button and select Selected branches and tags.

  Setting environment restrictions

• Click on Add deployment branch or tag rule, enter "production" in the Name pattern field, and click on Add rule.

  Setting environment branch Setting environment branch

• Under Environment secrets, click on Add secret.

  Add secret

Retrieve the private key you generated earlier by running:

cat /tmp/ssh_key

In the GitHub environment settings:

• For Name, enter STACKHERO_SSH_PRIVATE_KEY and paste your private key into the Value field.

  Setting the SSH private key secret

• In the Environment variables section, click on Add variable.

  Setting variables

• For Name, enter STACKHERO_ENDPOINT and paste your PHP service endpoint into the Value field. You can find this endpoint in your Stackhero dashboard.

  Setting the endpoint variable

If you have customised your service's domain name, use the customised version instead of <XXXXXX>.stackhero-network.com.

Delete the generated keys

For security reasons, it is a good idea to remove the generated SSH keys from your computer after setup:

rm /tmp/ssh_key /tmp/ssh_key.pub

Configure the GitHub Actions workflow

Now you will set up a GitHub Actions workflow file to automate your deployments. Inside your Git repository, create a directory named .github/workflows and add a file called deploy-to-stackhero.yml with the following content:

# File: .github/workflows/deploy-to-stackhero.yml

name: Deploy to Stackhero
run-name: Deploy branch "${{ github.ref_name }}" to Stackhero

on:
  push:
    # List of branches that will trigger the deploy action following a git push
    # Do not forget to create a corresponding environment in GitHub (under "Settings" -> "Environments") for each branch
    # Then add the secret "STACKHERO_SSH_PRIVATE_KEY" and variable "STACKHERO_ENDPOINT" in that environment
    branches: [ "production", "staging" ]

jobs:
  Deploy:
    environment: ${{ github.ref_name }}
    runs-on: ubuntu-latest
    steps:
    - uses: stackhero-io/github-actions-deploy-to-stackhero@v1
      with:
        # The secret "STACKHERO_SSH_PRIVATE_KEY" and the variable "STACKHERO_ENDPOINT" should be defined in the corresponding GitHub environment (under "Settings" -> "Environments")
        ssh_private_key: ${{ secrets.STACKHERO_SSH_PRIVATE_KEY }}
        endpoint: ${{ vars.STACKHERO_ENDPOINT }}

Once you have added this file, you can commit your changes by running these commands in your terminal:

git add -A .
git commit -m "Add GitHub Actions to deploy to Stackhero"

To create the production branch, you might run:

git checkout -b production

Then push your changes to GitHub:

git push --set-upstream origin production

This will push your code to the production branch on GitHub. GitHub Actions will then automatically run and deploy your code to the associated Stackhero instance. To check the deployment status, you can visit your GitHub project and click on Actions.

GitHub Actions that deployed to production

Congratulations! Your project is now set up for automatic deployment to production using GitHub Actions.

Creating the staging environment

You can set up your staging environment in much the same way as the production environment. Just repeat the steps above, substituting production with staging where appropriate.

Once the settings are configured, you can create your staging branch like this:

git checkout -b staging

Then push it to GitHub:

git push --set-upstream origin staging

GitHub Actions will automatically deploy the code from your staging branch to the PHP service you have set up for staging.

Going further

To help ensure your application stays reliable and secure, it is a good idea to protect your production and staging branches against direct pushes. You could set things up so that changes are made via pull requests, perhaps having the staging branch reviewed and merged only by those with deployment rights. Once your changes are validated in staging, authorized users can merge them into the production branch.

Taking this approach means only vetted code makes it to production, and you get to test new features in staging before they go live, which can give you and your team extra peace of mind.