> ## Documentation Index
> Fetch the complete documentation index at: https://bunny.net/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# PHP API with Slim

> Deploy a PHP API with Slim Framework to Magic Containers

This guide walks you through building and deploying a PHP API using Slim Framework to Magic Containers with GitHub Container Registry. You'll need:

* A GitHub account for source code and container registry

> [!TIP]
>
> Don't have a bunny.net account yet? [Sign up](https://dash.bunny.net/auth/register) and enable Magic Containers to get started.

## Create the Slim app

Create a new directory and initialize the project:

```bash theme={null}
mkdir app-slim-api
cd app-slim-api
composer require slim/slim slim/psr7
```

Create the following files:

```php public/index.php theme={null}
<?php

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

require __DIR__ . '/../vendor/autoload.php';

$app = AppFactory::create();

$app->get('/', function (Request $request, Response $response) {
    $response->getBody()->write(json_encode(['message' => 'Hello from Bunny 🐰']));
    return $response->withHeader('Content-Type', 'application/json');
});

$app->run();
```

```json composer.json theme={null}
{
  "require": {
    "slim/slim": "^4.0",
    "slim/psr7": "^1.0"
  }
}
```

## Run locally

Start the PHP development server:

```bash theme={null}
php -S localhost:8080 -t public
```

Test the API:

```bash theme={null}
curl http://localhost:8080/
```

## Create the Dockerfile

```dockerfile Dockerfile theme={null}
FROM php:8.3-apache

RUN a2enmod rewrite

COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

WORKDIR /var/www/html

COPY composer.json .
RUN composer install --no-dev --optimize-autoloader

COPY public/ public/

RUN sed -i 's|/var/www/html|/var/www/html/public|g' /etc/apache2/sites-available/000-default.conf
RUN echo '<Directory /var/www/html/public>\n\
    AllowOverride All\n\
    Require all granted\n\
</Directory>' >> /etc/apache2/apache2.conf

RUN echo 'RewriteEngine On\n\
RewriteCond %{REQUEST_FILENAME} !-f\n\
RewriteCond %{REQUEST_FILENAME} !-d\n\
RewriteRule ^ index.php [QSA,L]' > public/.htaccess

EXPOSE 80
```

## Build and push to GitHub Container Registry

**GitHub Actions**

Create `.github/workflows/build.yml` to automatically build and push on every commit to `main`:

```yaml .github/workflows/build.yml theme={null}
name: Build and Push

on:
  push:
    branches: [main]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write

    steps:
      - uses: actions/checkout@v4

      - name: Log in to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and push
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}

      - name: Update container image on Magic Containers
        uses: BunnyWay/actions/container-update-image@main
        with:
          app_id: ${{ vars.APP_ID }}
          api_key: ${{ secrets.BUNNYNET_API_KEY }}
          container: app
          image_tag: "${{ github.sha }}"
```

Push your code to trigger the workflow:

```bash theme={null}
git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/YOUR_USERNAME/app-slim-api.git
git push -u origin main
```

**Docker CLI**

Build and push manually from your local machine.

**1. Create a Personal Access Token**

Go to [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens) and create a token with `write:packages` scope.

**2. Log in to GitHub Container Registry**

```bash theme={null}
export CR_PAT=your_personal_access_token
echo $CR_PAT | docker login ghcr.io -u YOUR_USERNAME --password-stdin
```

**3. Build the image**

```bash theme={null}
docker build --platform linux/amd64 -t ghcr.io/YOUR_USERNAME/app-slim-api:latest .
```

> [!NOTE]
>
> Magic Containers only supports images built for the **linux/amd64** architecture. The `--platform` flag ensures compatibility regardless of your local machine's architecture.

**4. Push to registry**

```bash theme={null}
docker push ghcr.io/YOUR_USERNAME/app-slim-api:latest
```

> [!NOTE]
>
> If your package is private, set the visibility to **Public** in GitHub or
> [configure Magic Containers with registry
> credentials](/docs/magic-containers/image-registries.md).

## Deploy to Magic Containers

**1. Create a new app**

In the bunny.net dashboard, go to **Magic Containers** and click **Add
App**. Enter a name and select your deployment option.

**2. Add a container**

Click **Add Container**, then configure:

| Field | Value |
| - | - |
| Registry | GitHub Container Registry |
| Image | `YOUR_USERNAME/{imageName}` |
| Tag | `latest` for Docker CLI, or the commit SHA from your GitHub Actions workflow |

**3. Add an endpoint**

Go to the **Endpoints** tab, click **Add New Endpoint**, and set the
container port to `80`.

**4. Deploy**

Click **Add Container**, then **Next Step**, and **Confirm and Create**.

For more details, see the [quickstart guide](/docs/magic-containers/quickstart.md).

## Test your API

```bash theme={null}
curl https://mc-xxx.bunny.run/
```

```json Response theme={null}
{ "message": "Hello from Bunny 🐰" }
```

> [!NOTE]
>
> You can [add a custom hostname](/docs/magic-containers/endpoints.md) from the **Endpoints** section in your app settings.

## Connect a database

You can connect your app to [Bunny Database](/docs/database.md) directly from the dashboard:

1. Go to **Database > \[Your Database] > Access**
2. Click **Generate Tokens**
3. Click **Add Secrets to Magic Container App**
4. Select your app

The `BUNNY_DATABASE_URL` and `BUNNY_DATABASE_AUTH_TOKEN` environment variables are now available in your app. Install the libSQL PHP extension or use HTTP requests to connect:

```php theme={null}
<?php

$dbUrl = getenv('BUNNY_DATABASE_URL');
$dbToken = getenv('BUNNY_DATABASE_AUTH_TOKEN');

$ch = curl_init($dbUrl);
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $dbToken,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'statements' => ['SELECT * FROM users']
    ]),
]);

$result = json_decode(curl_exec($ch), true);
curl_close($ch);
```

See the [Bunny Database documentation](/docs/database.md) for more details.

## Next steps

1. [Automate deploys with GitHub Actions](/docs/magic-containers/deploy-with-github-actions.md)
2. [Add a custom hostname](/docs/magic-containers/endpoints.md)
3. [Add a persistent volume](/docs/magic-containers/persistent-volumes.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.