PHP Laravel Development with Kubernetes using DevSpace - Developer Edition
Tags: kubernetes, devspace, php, laravel
Published: 2021-08-20 17:43:07

---
title: PHP Laravel Development with Kubernetes using DevSpace - Developer Edition
published: true
description: A look at using DevSpace to develop PHP applications that run in Kubernetes clusters
tags: Kubernetes, DevSpace, PHP, Laravel
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4se5s3cdmoedtmp0f433.jpg
canonical_url: https://loft.sh/blog/php-laravel-development-with-kubernetes-using-devspace-developer-edition/
---
by Levent Ogut

Kubernetes is an excellent open-source container orchestration platform that brings automatic scaling, automatic recovery, observability, and many more features. Since it differs from traditional operations, it has changed the development and deployment workflows as well. Debugging an application on Kubernetes can be a challenge. DevSpace is a tool that helps you develop, deploy, troubleshoot simple or complex applications. We will use a Laravel project to demonstrate its features; Laravel is a popular framework used by the PHP community with great features like extensibility, inheritance, and reusability with high customization options.

## Architecture

We will look at ways to deploy a Laravel based application into a Kubernetes cluster for development and production environments. We will develop our application while the application is running in Kubernetes as if we are developing locally. And we will be able to troubleshoot our application in real-time with ease.

The desired setup uses four containers, in three pods:

* PHP-FPM container, which processes all the PHP assets.
* Nginx container, which serves static files and acts as a reverse proxy for the PHP assets.
* MySQL container, as the database.
* Redis container, as session and cache.

## Introduction to DevSpace

Continuous Delivery is a challenge while developing on Kubernetes. Without using a special tool, you need to build and deploy every time code or assets change. [DevSpace](https://devspace.sh/) handles this seamlessly either by synchronizing files and hot reload of the container in question or automatically rebuilding and deploying the image(s) required. DevSpace allows you to develop in a Kubernetes cluster as if you are developing in your local machine.

### Feature Highlights

* **Agile development on local and remote Kubernetes clusters**. Execution of entire continuous development and deployment pipeline, and a single command to deploy all components of your application.
* **Declarative configuration kept in source code**, in the devspace.yaml file. All of the development, deployment, and pre/post-deployment actions are defined in a single file.
* **Hot Reloading for faster feedback**. Instead of building and re-deploying artifacts, DevSpace allows you to use high-performance and bi-directional file synchronization. This allows changes to trigger a hot-reload on the deployed container. All of these features are highly configurable.
* **Extensibility**. You can extend the functionality of DevSpace via the plugin system. Hooks and commands are also built-in constructs; you can expand the functionality heavily used in CI/CD pipelines.
* **Easy clean Up**. You can delete the resources created via \`devspace purge\` in a single simple step.
* **Client Only**. DevSpace doesn't require server/cluster side components. A single executable on a local machine is sufficient to develop, troubleshoot and deploy.

## Requirements and Setting Up Development Environment

The following tools should be installed on your local development machine:

* Kubectl, documentation [here](https://kubernetes.io/docs/tasks/tools/).
* Helm, documentation [here](https://helm.sh/docs/intro/install/).
* DevSpace, installation instructions [here](https://devspace.sh/cli/docs/getting-started/installation).

## Developing with DevSpace

First, let's start with the code. Clone the repository to your local development machine as follows. This code includes a vanilla Laravel installation, a Dockerfile, and a devspace.yaml prepopulated.

```Bash
$ git clone git@github.com:loft-sh/devspace-php-laravel-nginx.git
```

Copy .env.example to .env.

```Bash
$ cp .env.example .env
```

Now open the .env file and modify where necessary, like adjusting port numbers if needed.

After this, we can generate the Laravel APP_KEY variable via the following command:

```Bash
$ devspace run generate-key
```

Review the variables by running the `devspace list vars` command, and set variables where necessary.

```Bash
$ devspace list vars
```

DevSpace will ask you a few questions regarding the image repository and other variables not defined in the .env file, and then show the output of the variables.

```
 Variable              Value                                                
 APP_DEBUG             true                                                 
 APP_IMAGE             leventogut/php-laravel-nginx-devspace                
 APP_KEY               xxxxxxxxxxxxxxxx  
 ASSET_VOLUME_NAME     static-asset-volume                                  
 ASSET_VOLUME_SIZE     1Gi                                                  
 DB_DATABASE           laravel                                              
 DB_HOST               mysql                                                
 DB_MYSQL_VERSION      8.0.23                                               
 DB_PASSWORD           xxxxxxxxxxxxxxxx                                     
 DB_PORT               3306                                                 
 DB_ROOT_PASSWORD      xxxxxxxxxxxxxxxx                                     
 DB_USERNAME           laravel                                              
 NGINX_CONFIG_HASH     740941                                               
 NGINX_IMAGE_VERSION   1.9                                                  
 REDIS_PASSWORD        xxxxxxxxxxxxxxxx                                    
 REDIS_VERSION         6.0.12  
```

### Running devspace dev

DevSpace is context-aware; it follows your Kubernetes config to determine the Kubernetes cluster to deploy on.  However, It is good practice to set the context and namespace to use with:

```Bash
$ devspace use context docker-desktop
```

```
[info]   Your kube-context has been updated to 'docker-desktop'
         To revert this operation, run: devspace use context maple-staging

[done] √ Successfully set kube-context to 'docker-desktop'
```

```Bash
$ devspace use namespace laravel
```

```
[info]   The default namespace of your current kube-context 'docker-desktop' has been updated to 'laravel'
         To revert this operation, run: devspace use namespace 

[done] √ Successfully set default namespace to 'laravel'
```

Now that we have all the variables and the configs, we can start in-cluster development:

```Bash
$ devspace dev
```

DevSpace will build the artifacts we have defined in the `devspace.yaml`, deploy all components, and start log streaming from the configured containers. This might take a few minutes.

In a few minutes, DevSpace will open a browser window showing a login screen. Previously, we have installed the laravel/ui package to test MySQL and Redis. Simply register as a new user, and you will be redirected to the index page. The index page has several links, including a link to the ping/pong route we will use in a few steps.

![Screenshot of the PHP app's UI](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y4hb4shgy5o9eeaadbx0.png)

### Workflow

At this stage, we have deployed our application into the Kubernetes cluster, and DevSpace is watching any changes on the project directory.

Now, having started DevSpace in development mode, we can change our code and see the immediate effect on our application that is running in the Kubernetes cluster.

Open the web.php file under the routes directory with your favorite editor. And paste the following code.

```php
Route::get('ping', function () {
    return "pong";
})
```

Any asset added to the repo folder will also be synced (according to the sync rules defined) to the container.

At this stage, you can try adding controllers, routes, dependencies and observe the ease of development.

### Port Forwarding and Reverse Port Forwarding

You can reach the application via port forwarding. These can be defined in the `devspace.yaml` file. In the current configuration, the Nginx container's port 80 is forwarded to local port 8080. The browser will be automatically opened after a successful deployment and start of the containers.

You can configure reverse port forwarding as well, which is very useful for certain debugging tools.

### Commands

Our sample `devspace.yaml` includes some Laravel and MySQL-specific commands to ease development workflow.

You can run any artisan, composer, php, and npm commands and additionally drop into a MySQL shell with a single mysql command.

You can list available commands via:

```Bash
$ devspace list commands
```

```
 Name           Command                                                            Description
 artisan        devspace enter -c php -- php artisan                               Entry point for artisan commands.
 composer       devspace enter -c php -- composer                                  Entry point for composer commands.
 php            devspace enter -c php -- php                                       Entry point for PHP commands.
 npm            devspace enter -c php -- npm                                       Entry point for NPM commands.
 generate-key   TMP_FILE=.devspace/app_key.tmp && docker run --rm -v $PWD:/ap...   Generate APP_KEY.
 mysql          devspace enter -c mysql -- mysql -h'mysql' -P'3306' -u'larave...   Enter to MySQL shell.
```

Try these commands to get familiar with them in your workflow.

### Hooks

[Hooks](https://devspace.sh/cli/docs/configuration/hooks/basics) are a quite valuable feature of DevSpace. With hooks, you can run commands before and after certain deployments.

We have defined several hooks in the devspace.yaml file, such as:

* Changing MySQL user and password
* Running `npm run watch` on the PHP container.
* Reloading Nginx to re-read the configuration.

## Deploying to Production

The `devspace deploy` command will deploy our application into the environment we define. DevSpace configuration allows us to modify and alter our parameters based on profiles. This flexibility brings numerous configuration options for development, staging, production environments. DevSpace configuration can hold all different parameters and configurations for each environment. Generally speaking, it is a good practice to create a production profile for deployment, which will remove troubleshooting aids and set parameters accordingly.

Our prepared `devspace.yaml` consists of a production profile that will remove the additions we have made to make developing and troubleshooting easy.

Deploy with production profile:

```Bash
$ devspace deploy -p production
```

## Troubleshooting with DevSpace

Troubleshooting and debugging are pretty straightforward with DevSpace. DevSpace provides aid for the following:

* Logging
* Entering into containers
* Running commands inside the containers
* Interactive mode

### Entering to and Working with Containers

The `devspace enter` command allows you to open a shell to any of the running containers by providing the container name, so you don't have to deal with the copy/paste of long pod names.

```Bash
$ devspace enter -c php
```

```
[info]   Using namespace 'default'
[info]   Using kube context 'docker-desktop'
[info]   Opening shell to pod:container app-0:php
root@app-0:/var/www/html# 
```

If a container is not specified, a selector will be displayed, and you can choose from the available containers:

```
? Which pod do you want to open the terminal for?
  [Use arrows to move, type to filter]
> redis-master-0:redis  app-0:nginx
  app-0:php
  mysql-0:mysql
```

## Testing

As you can execute any command in the container, running the tests you have for the application is a breeze.

You can easily run phpunit or artisan test commands for running your tests.

```Bash
$ devspace run php ./vendor/bin/phpunit
```

```
[info]   Using namespace 'default'
[info]   Using kube context 'docker-desktop'
[info]   Opening shell to pod:container app-0:php
PHPUnit 9.5.3 by Sebastian Bergmann and contributors.

.F                                                                  2 / 2 (100%)

Time: 00:00.122, Memory: 20.00 MB

There was 1 failure:

1) Tests\Feature\ExampleTest::testBasicTest
Expected status code 200 but received 302.
Failed asserting that 200 is identical to 302.

/var/www/html/vendor/laravel/framework/src/Illuminate/Testing/TestResponse.php:187
/var/www/html/tests/Feature/ExampleTest.php:19

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.
```

Let's run `artisan test`:

```Bash
$ devspace run artisan test
```

```
[info]   Using namespace 'default'
[info]   Using kube context 'docker-desktop'
[info]   Opening shell to pod:container app-0:php

   PASS  Tests\Unit\ExampleTest
  ✓ basic test

   FAIL  Tests\Feature\ExampleTest
  ⨯ basic test

  ---

  • Tests\Feature\ExampleTest > basic test
  Expected status code 200 but received 302.
  Failed asserting that 200 is identical to 302.

  at tests/Feature/ExampleTest.php:19
     15▕     public function testBasicTest()
     16▕     {
     17▕         $response = $this->get('/');
     18▕ 
  ➜  19▕         $response->assertStatus(200);
     20▕     }
     21▕ }
     22▕ 


  Tests:  1 failed, 1 passed
  Time:   0.19s
```

## CI/CD

DevSpace configuration can hold many profiles and can be used for different deployment options. It is common to see developers use DevSpace for their CI/CD pipeline as well. Deploying your application into the CI/CD pipeline is relatively straightforward. The ability to choose from various profiles makes it a breeze to switch from development to staging and production.

## Clean Up

You can easily clean your environment with the \`devspace purge\` command. This will be deleting all deployments. Please note that purge will not delete persistent storage(s).

## Conclusion

We have seen DevSpace in action while developing, deploying, and troubleshooting. We have seen that once DevSpace is configured, it can encompass all deployment options within it. So it can be used for development and deployment to any environment. The ability to change profiles, add new commands, and execute any hooks is advantageous.

The second part of this series will delve into how to configure DevSpace, and we will go over the many possible configuration options.

## Further Reading

* [DevSpace Docs](https://devspace.sh/cli/docs/introduction)

*Photo by [Ben](https://unsplash.com/@benofthenorth?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/@benofthenorth?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)*