---
title: "Jak wdrożyć aplikację PHP w 2026"
description: "Wdróż aplikację PHP jednym poleceniem: pethost deploy pisze Dockerfile dla Laravela, Symfony lub zwykłych stron PHP i serwuje ją przez HTTPS za 9,99 €/mies."
---

[Blog](https://pethost.dev/pl/blog/) · Poradniki wdrożeń

# Jak wdrożyć aplikację PHP w 2026: Laravel, Symfony albo zwykłe strony PHP jednym poleceniem

Zespół Pethost · 24 października 2026 · Zaktualizowano 28 października 2026 · 10 min czytania

Masz aplikację PHP, która działa na twoim laptopie: projekt Laravel, projekt Symfony albo katalog stron `.php`. Chcesz ją mieć w sieci z HTTPS, bez stawiania serwera. Na Pethost to jedno polecenie, `pethost deploy`, uruchomione w katalogu aplikacji: samo pisze Dockerfile, buduje aplikację na twojej maszynie Pethost i wypisuje jej adres. Świeży projekt z `laravel new` zbudował się i uruchomił w 1 minutę 29 sekund, a katalog z dwiema stronami w 12 sekund.

**W skrócie**

- **Jedno polecenie:** `pethost deploy` w katalogu z `composer.json` albo, dla zwykłych stron, z `index.php`. Nie trzeba pisać pliku konfiguracyjnego.
- **Laravel i Symfony** działają na FrankenPHP z PHP 8.4. pethost uruchamia `composer install`, buduje assety Vite i uruchamia aplikację w trybie produkcyjnym.
- **Zwykłe strony PHP** działają na Apache, z twoimi plikami `.htaccess` i `mod_rewrite`.
- **Baza SQLite Laravela** jest trzymana w wolumenie i migrowana przy każdym starcie, więc nowe wdrożenie zachowuje dane.
- **Cena:** 9,99 € miesięcznie za 2 vCPU, 3 GB i 30 GB, na każdy twój projekt. Nie ma darmowego planu.

## Czego potrzebujesz, żeby wdrożyć aplikację PHP w 2026

Trzech rzeczy: aplikacji, polecenia `pethost` i konta Pethost.

**Aplikacja** to katalog na twoim komputerze: tutaj projekt utworzony przez `laravel new`, szkielet Symfony z jedną stroną i dwie strony w czystym PHP. Docker na twoim komputerze nie jest potrzebny: obraz buduje się na twojej maszynie Pethost.

**Polecenie** to jeden program, instalowany jedną linią. Wszystkie jego polecenia są w [dokumentacji CLI](https://pethost.dev/docs/cli/).

```
curl -fsSL https://pethost.dev/install.sh | sh      # macOS, Linux
irm https://pethost.dev/install.ps1 | iex           # Windows, in PowerShell
```

**Konto** potrzebuje planu. Jeśli nie jesteś zalogowany, `pethost deploy` otwiera przeglądarkę i cię loguje. Jeśli nie masz jeszcze planu, pokazuje, gdzie go wybrać, i czeka.

## Wdróż aplikację Laravel

Aplikacja to ta, którą zostawia instalator Laravela: `laravel new example-app`, bez starter kitu, z SQLite jako bazą danych, z Pestem oraz z `npm install` i buildem, które robi instalator. Przejdź do jej katalogu i uruchom `pethost deploy`. Oto cały ekran:

```
$ cd example-app
$ pethost deploy
Name it [example-app]:      it will live at https://example-app.sam.pethost.app
✓ Packed 10.4k files, 51 MB   (left out node_modules · took .env from this folder)
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ Laravel project detected, wrote Dockerfile and .dockerignore.
~ The database starts empty on the machine and is migrated at each start: pethost run -- php artisan db:seed --force fills it from the project's seeders.
✓ Packed 10.4k files, 51 MB   (left out node_modules · took .env from this folder)
✓ Uploaded straight to your machine
✓ Built and started in 1 min 29 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 80, a named volume at /app/storage/app
✓ app listens on 80 → https://example-app.sam.pethost.app
  It answers 200.

https://example-app.sam.pethost.app

Wrote .pethost (commit it). Next:   pethost logs -f   ·   pethost open
```

1. **Pyta o jedno** O nazwę projektu, która jest pierwszym słowem jego adresu. Enter bierze nazwę katalogu.
2. **Maszyna nie znajduje nic do uruchomienia** Linia z krzyżykiem to jej odpowiedź: projekt działa z Dockerfile albo z pliku Compose, a w katalogu nie ma jeszcze żadnego z nich.
3. **pethost pisze Dockerfile** `composer.json` wymaga `laravel/framework`, więc pisze Dockerfile dla Laravela i wgrywa katalog jeszcze raz.
4. **Maszyna buduje i uruchamia aplikację** Potem pethost odpytuje adres i wypisuje odpowiedź: 200, stronę powitalną Laravela.

Twój `.env`, razem z `APP_KEY`, stał się plikiem projektu na maszynie. `.pethost` mówi, którym projektem jest ten katalog: zrób jego commit razem z Dockerfile, a następne wdrożenie o nic nie zapyta.

### Dockerfile, który pethost pisze dla Laravela

Oto linie pliku zapisanego w katalogu, które mają znaczenie. Jego 54 linie mówią w komentarzach, po co jest każdy krok:

```
# check=skip=JSONArgsRecommended
# Written by pethost deploy for this Laravel project: composer.json requires
# laravel/framework, package.json builds the assets with "vite build", npm installs it
# (package-lock.json), its SQLite database is kept in storage/app, with the files the
# site is given, it runs in production mode, set over the folder's .env.
# It is yours now: change it as you like. pethost does not write it again.

FROM dunglas/frankenphp:1-php8.4
…
COPY . .

RUN composer install
…
RUN npm run build

ENV DB_DATABASE=/app/storage/app/database.sqlite
# The machine keeps this directory across deploys.
VOLUME /app/storage/app
EXPOSE 80
…
CMD export APP_ENV=production APP_DEBUG=false LOG_CHANNEL=stderr DB_DATABASE=/app/storage/app/database.sqlite && \
    php artisan migrate --force && \
    exec frankenphp run --config /etc/frankenphp/Caddyfile
```

- **Serwer** to FrankenPHP, zbudowany na Caddy, z PHP 8.4. Aplikacja wie, że działa za HTTPS, więc adresy URL, które pisze Laravel, zaczynają się od `https://`. Rozszerzenia, których `composer.json` wymaga jako `ext-…`, są instalowane.
- **Tryb produkcyjny** jest ustawiany przy starcie, ponad `.env` z twojego laptopa, a logi idą na wyjście kontenera, skąd czyta je `pethost logs`.
- **Plik SQLite** leży w `storage/app`, który maszyna trzyma w wolumenie między wdrożeniami, a migracje uruchamiają się przed startem serwera.

## Uruchamiaj polecenia artisan na maszynie

`pethost run` uruchamia jedno polecenie w kontenerze aplikacji. Tutaj własne migracje Laravela, po trzech wdrożeniach:

```
$ pethost run -- php artisan migrate:status
example-app (.pethost)

  Migration name .............................................. Batch / Status
  0001_01_01_000000_create_users_table ............................... [1] Ran
  0001_01_01_000001_create_cache_table ............................... [1] Ran
  0001_01_01_000002_create_jobs_table ................................ [1] Ran
```

Wszystkie trzy są w batchu 1: uruchomiły się przy pierwszym starcie, a baza przetrwała dwa kolejne wdrożenia. `pethost run -- php artisan db:seed --force` wypełnia ją z twoich seederów, tak jak mówiła linia z tyldą, a `pethost shell` otwiera powłokę dla `php artisan tinker`.

Projekt Laravel, którego `.env` wskazuje MySQL albo Postgres, nie dostaje Dockerfile, bo baza danych musi działać obok niego. pethost to mówi:

```
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
  .env names a database other than SQLite (DB_CONNECTION=pgsql), and the machine runs none beside a Dockerfile: the project needs a compose.yaml with the site and its database.
```

`compose.yaml` z aplikacją i jej bazą danych działa tak, jak go napisano. Możesz też jednym kliknięciem utworzyć bazę danych, bez dodatkowych kosztów, i podłączyć do niej aplikację: MariaDB dla aplikacji pisanej pod MySQL albo Postgres ([Postgres w stałej cenie](https://pethost.dev/pl/blog/european-hosting-postgres-flat-price/)).

## Wdróż aplikację Symfony

Aplikacja to szkielet Symfony, `composer create-project symfony/skeleton my-project` (to samo co `symfony new my-project`), z kontrolerem z przewodnika Symfony „Create your First Page”: `src/Controller/LuckyController.php`, którego trasa `/lucky/number` odpowiada losową liczbą. To samo polecenie ją wdraża:

```
$ cd my-project
$ pethost deploy
Name it [my-project]:        it will live at https://my-project.sam.pethost.app
✓ Packed 1.7k files, 7.9 MB   (took .env from this folder)
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ Symfony project detected, wrote Dockerfile and .dockerignore.
✓ Packed 1.7k files, 7.9 MB   (took .env from this folder)
✓ Uploaded straight to your machine
✓ Built and started in 57 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 80
✓ app listens on 80 → https://my-project.sam.pethost.app
  It answers 404.

https://my-project.sam.pethost.app

Wrote .pethost (commit it). Next:   pethost logs -f   ·   pethost open
```

Odpowiedź to 404, bo aplikacja nie ma trasy pod `/`, a na produkcji Symfony nie pokazuje strony powitalnej. Odpytaj trasę, która istnieje:

```
$ curl https://my-project.sam.pethost.app/lucky/number
<html><body>Lucky number: 27</body></html>
```

Dockerfile dla Symfony to ten dla Laravela bez Node'a i bazy danych. `APP_ENV=prod` jest ustawiany dla `composer install`, który rozgrzewa cache, i przy starcie, ponad `.env`, który Symfony commituje z `APP_ENV=dev`. Assety AssetMappera są kompilowane w buildzie. Projekt z encjami Doctrine w `src/Entity` nie dostaje Dockerfile: potrzebuje `compose.yaml` ze swoją bazą danych.

## Wdróż zwykłe strony PHP

Bez frameworka, bez Composera: katalog z `index.php`, który pokazuje formularz, i `hello.php`, który czyta `$_POST['name']` i się wita.

```
$ cd my-site
$ pethost deploy
Name it [my-site]:              it will live at https://my-site.sam.pethost.app
✓ Packed 2 files, 604 B
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ PHP site detected, wrote Dockerfile.
~ Every file of the folder is public at its address, but for the Dockerfile and names that begin with a dot.
✓ Packed 3 files, 1 KB
✓ Uploaded straight to your machine
✓ Built and started in 12 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 80
✓ app listens on 80 → https://my-site.sam.pethost.app
  It answers 200.

https://my-site.sam.pethost.app

Wrote .pethost (commit it). Next:   pethost logs -f   ·   pethost open
```

```
$ curl -d name=Sam https://my-site.sam.pethost.app/hello.php
…
  <p>Hello, Sam!</p>
```

Dockerfile to oficjalny obraz PHP `php:8.4-apache`, który serwuje katalog, z produkcyjnymi ustawieniami PHP. Pliki `.htaccess` działają, a `mod_rewrite` jest włączony. Przeczytaj linię z tyldą: każdy plik w katalogu jest publiczny, więc sekret trafia do zmiennych projektu. Strony, które otwierają bazę danych przez `mysqli` albo `PDO`, potrzebują `compose.yaml` z tą bazą, i pethost to mówi.

## Zmień kod i wdróż ponownie

Dodaj trasę do `routes/web.php` i uruchom to samo polecenie:

```
Route::get('/hello', function () {
    return 'Hello from Laravel!';
});
```

```
$ pethost deploy
example-app (.pethost)
✓ Packed 10.4k files · uploaded · built and started in 48 s
  · kept the project's .env in place of the version's own: after the first deploy the project's is kept
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 80, a named volume at /app/storage/app
  · kept the project's x-pethost
  It answers 200.
https://example-app.sam.pethost.app
To send this folder's .env:  pethost env push
```

Zwróć uwagę na drugą linię: po pierwszym wdrożeniu maszyna trzyma `.env` projektu, a nie ten z twojego laptopa. `pethost env set` zmienia zmienną i od razu wdraża:

```
$ pethost env set APP_URL=https://example-app.sam.pethost.app
example-app (.pethost)
✓ /.env has APP_URL now. Deployed in 48 s.
```

Sama nazwa pyta o sekret, nie pokazując go: `pethost env set MAIL_PASSWORD`. `pethost github sam/example-app` od tej chwili wdraża każdy push, a `pethost rollback` przywraca poprzednią wersję. Agent AI może zrobić to wszystko przez serwer MCP Pethost: [jak agent wdraża projekt i o niego dba](https://pethost.dev/pl/blog/hosting-for-ai-coding-agents/).

## Użyj własnej domeny dla aplikacji PHP

Każda nazwa pod domeną twojego konta działa od razu, z HTTPS. Domena, którą masz, to jedno polecenie i jeden rekord DNS:

```
pethost domain add www.example.com
```

Polecenie wypisuje rekord: CNAME na nazwę twojej maszyny. Certyfikat pojawia się, gdy tylko nazwa zacznie się rozwiązywać, i sam się odnawia.

## Co dostajesz za tę cenę

Pethost kosztuje 9,99 € miesięcznie za wszystko, co hostujesz, na 2 vCPU, 3 GB pamięci i 30 GB dysku. To miejsce na aplikację Laravel, jej workera kolejki, bazę danych i twój następny projekt, bez [opłaty za projekt](https://pethost.dev/pl/blog/unlimited-projects-flat-monthly-fee/) i bez żadnych liczników. Maszyna działa cały czas, więc odwiedzający [nigdy nie czeka na zimny start](https://pethost.dev/pl/blog/always-on-hosting-no-cold-starts/).

- **9,99 €** miesięcznie za wszystkie twoje projekty, bez liczników
- **1 min 29 s** na zbudowanie i uruchomienie nowej aplikacji Laravel za pierwszym razem
- **12 s** dla katalogu stron PHP

Co jest już zrobione za ciebie: HTTPS z certyfikatami, które same się odnawiają, wdrożenia z GitHuba, nocne backupy trzymane przez 14 dni, SSH do każdego kontenera i każde żądanie policzone, bez żadnego skryptu na twoich stronach. Plany są w [cenniku](https://pethost.dev/pl/#pricing) na stronie głównej.

**Każdy projekt podpisany.** Siedem projektów na jednej maszynie Starter: aplikacje z adresami i żądaniami z ostatniego dnia, bazy danych z aplikacjami, które ich używają.

![Pierwsza strona panelu Pethost: CPU, pamięć i dysk maszyny oraz jej projekty jako karty.](https://pethost.dev/shots/projects.webp)

### Pethost to najlepszy wybór dla

- **Programistów PHP z aplikacją Laravel albo Symfony**, którzy chcą ją mieć w sieci bez utrzymywania serwera
- **Osób, które odchodzą od hostingu współdzielonego** z katalogiem stron PHP i kilkoma kolejnymi projektami w planach
- **Osób, za które wdraża agent**: Claude Code albo Codex wystawia aplikację do sieci i czyta jej logi
- **Wczesnych startupów**, które chcą stałego miesięcznego kosztu, póki produkt jest mały

### Poszukaj gdzie indziej, jeśli

- Twoja aplikacja potrzebuje kilku regionów albo autoskalowania

## Pytania

### Jak wdrożyć aplikację PHP bez pisania Dockerfile?

Uruchom `pethost deploy` w katalogu aplikacji. Dla projektu Laravel albo Symfony, albo dla katalogu z `index.php`, pisze Dockerfile i go wdraża. Plik zostaje w twoim katalogu i możesz go zmieniać.

### Jakiej wersji PHP używa Pethost?

Dockerfile, które pisze pethost, uruchamiają PHP 8.4: na FrankenPHP dla Laravela i Symfony, na Apache dla zwykłych stron. Wersja jest w linii `FROM` Dockerfile, a ten plik jest twój.

### Czy baza SQLite w Laravelu przetrwa ponowne wdrożenie?

Tak. Plik leży w `storage/app`, który maszyna trzyma w wolumenie, a każdy start uruchamia `php artisan migrate --force`. Dwa wdrożenia później migracje wciąż pokazywały batch 1.

### Czy mogę wdrożyć aplikację Laravel z MySQL albo Postgres?

Tak, z `compose.yaml`, który uruchamia aplikację obok jej bazy danych: pethost nie pisze dla niej Dockerfile i to mówi. Możesz też podłączyć aplikację do bazy danych utworzonej jednym kliknięciem, bez dodatkowych kosztów: MariaDB dla aplikacji pisanej pod MySQL albo Postgres.

### Ile kosztuje hosting aplikacji PHP na Pethost?

9,99 € miesięcznie za plan Starter, z 2 vCPU, 3 GB i 30 GB, bez opłaty za projekt: twoje inne aplikacje i bazy danych też tam działają. Nie ma darmowego planu. Ceny są bez VAT.

Ekrany to wdrożenia na naszej maszynie testowej, z pethost 0.2.4: projekt utworzony przez instalator Laravela 5.32.0 (Laravel 13.38.0), szkielet Symfony 8.1.9 i dwie strony w czystym PHP, wszystko na PHP 8.4.27. Wdrożenie Laravela poszło pierwsze; to dla Symfony użyło obrazu FrankenPHP, który tamto już pobrało. Konto na nich to przykładowe `sam`.

1. [Laravel: instalacja](https://laravel.com/docs/13.x/installation)
2. [Laravel: wdrażanie](https://laravel.com/docs/13.x/deployment)
3. [Symfony: instalacja i konfiguracja frameworka](https://symfony.com/doc/current/setup.html)
4. [Symfony: tworzenie pierwszej strony](https://symfony.com/doc/current/page_creation.html)
5. [FrankenPHP: dokumentacja](https://frankenphp.dev/docs/)
6. [PHP: oficjalny obraz Dockera](https://hub.docker.com/_/php)
7. [pethost, narzędzie wiersza poleceń Pethost](https://pethost.dev/docs/cli/)

## Opublikuj swoje projekty jeszcze dziś

Wdrażaj aplikacje, boty i bazy danych ze swojego agenta, z GitHuba lub w przeglądarce, tyle, ile się zmieści, w jednej stałej cenie. Nic liczonego za zużycie, nic doliczanego.

[Hostuj wszystko za 9,99 €/mies.](https://console.pethost.dev/)

## Czytaj dalej

- 10 października 2026 [Jak wdrożyć aplikację Gin w 2026: jedno polecenie, HTTPS i Dockerfile, który zostaje u ciebie](https://pethost.dev/pl/blog/deploy-gin-app/) Wdróż aplikację Go Gin jednym poleceniem: pethost deploy pisze Dockerfile, buduje program i serwuje go przez HTTPS za 9,99 € miesięcznie.
- 10 października 2026 [Jak wdrożyć aplikację Go Fiber w 2026: jedno polecenie, HTTPS i Dockerfile, który zostaje u ciebie](https://pethost.dev/pl/blog/deploy-fiber-app/) Wdróż aplikację Go Fiber jednym poleceniem: pethost deploy pisze Dockerfile, buduje ją w 45 sekund i serwuje przez HTTPS za 9,99 € miesięcznie.
- 10 października 2026 [Jak wdrożyć aplikację Nuxt w 2026: jedno polecenie, serwer Node i HTTPS](https://pethost.dev/pl/blog/deploy-nuxt-app/) Wdróż aplikację Nuxt 4 jednym poleceniem: pethost deploy pisze Dockerfile, uruchamia nuxt build i startuje serwer Node z HTTPS za 9,99 € miesięcznie.
- 10 października 2026 [Jak wdrożyć aplikację React Router w 2026: Dockerfile z szablonu, jedno polecenie i HTTPS](https://pethost.dev/pl/blog/deploy-react-router-app/) Wdróż aplikację React Router z renderowaniem na serwerze: pethost deploy buduje Dockerfile z szablonu i serwuje ją przez HTTPS w 11 s, za 9,99 € miesięcznie.

[Wszystkie artykuły](https://pethost.dev/pl/blog/) · [O Pethost](https://pethost.dev/about/) · [Cennik](https://pethost.dev/pl/#pricing)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Szablony](https://pethost.dev/pl/templates/)
- [O nas](https://pethost.dev/about/)
- [Dokumentacja](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pl/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Regulamin](https://pethost.dev/terms/)
- [Prywatność](https://pethost.dev/privacy/)
- [Zwroty](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bazy danych

- [Postgres](https://pethost.dev/pl/postgres/)

Porównania

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pl/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pl/blog/coolify-cloud-vs-dokploy-cloud/)
- [Cennik Railway vs Render vs Fly.io](https://pethost.dev/pl/blog/railway-vs-render-vs-fly-io-pricing/)
- [Zarządzany hosting Docker Compose](https://pethost.dev/pl/blog/managed-docker-compose-hosting/)

Alternatywy

- [Alternatywy dla Railway](https://pethost.dev/pl/blog/railway-alternatives/)
- [Alternatywy dla Heroku](https://pethost.dev/pl/blog/heroku-alternatives/)
- [Alternatywy dla Dokploy](https://pethost.dev/pl/blog/dokploy-alternatives/)
- [Alternatywy dla Coolify](https://pethost.dev/pl/blog/coolify-alternatives/)
- [Alternatywy dla Render](https://pethost.dev/pl/blog/render-alternatives/)
- [Alternatywy dla Sliplane](https://pethost.dev/pl/blog/sliplane-alternatives/)