Autor: [Robert Zasilny](/autorzy/robert-zasilny) Ekspert bezpieczeństwa i compliance · Zweryfikowano Kwiecień 2026

1.  [HostGrade.pl](/)
2.  [Baza wiedzy](/baza-wiedzy)
3.  Composer — zarządzanie pakietami PHP

# Composer — zarządzanie pakietami PHP

Kategoria: [PHP](/baza-wiedzy) · Aktualizacja: Kwiecień 2026

## Czym jest Composer?

Composer to **menadżer zależności dla PHP** — odpowiednik npm dla Node.js lub pip dla Pythona. Pozwala deklarować zależności projektu (biblioteki, frameworki), automatycznie je pobierać z [Packagist](https://packagist.org) i generować autoloader PSR-4 dla klas PHP.

Powiązane tematy: [PHP OPcache](/baza-wiedzy/php-opcache-konfiguracja), [PHP-FPM konfiguracja](/baza-wiedzy/php-fpm-konfiguracja-optymalizacja), [Laravel na hostingu](/baza-wiedzy/laravel-na-hostingu) oraz [Git deploy na hosting](/baza-wiedzy/git-deploy-hosting). Do wyboru hostingu z PHP 8.x użyj [kalkulatora kosztów](/kalkulator).

## Instalacja Composera

```
# Linux/macOS — instalacja globalna
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
sudo mv composer.phar /usr/local/bin/composer
php -r "unlink('composer-setup.php');"

# Sprawdź wersję
composer --version

# Windows — pobierz Composer-Setup.exe z getcomposer.org
```

```
# Instalacja na serwerze hostingowym (bez sudo)
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php --install-dir=~/bin --filename=composer
# Dodaj ~/bin do PATH w ~/.bashrc
export PATH="$HOME/bin:$PATH"
```

## composer.json — struktura projektu

```
{
    "name": "firma/moj-projekt",
    "description": "Opis projektu",
    "type": "project",
    "require": {
        "php": "^8.1",
        "monolog/monolog": "^3.0",
        "guzzlehttp/guzzle": "^7.5"
    },
    "require-dev": {
        "phpunit/phpunit": "^10.0",
        "phpstan/phpstan": "^1.10"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "Tests\\": "tests/"
        }
    },
    "minimum-stability": "stable",
    "prefer-stable": true
}
```

## Podstawowe komendy

Komenda

Co robi

Kiedy używać

`composer install`

Instaluje zależności z composer.lock

Deploy, nowy developer — zawsze z lock file

`composer update`

Aktualizuje zależności do najnowszych w ramach constraintów

Lokalnie, świadomie — aktualizuje composer.lock

`composer require vendor/pakiet`

Dodaje nową zależność

Dodawanie biblioteki do projektu

`composer remove vendor/pakiet`

Usuwa zależność

Usuwanie nieużywanej biblioteki

`composer dump-autoload`

Regeneruje autoloader

Po dodaniu nowych klas bez Composera

`composer show`

Lista zainstalowanych pakietów

Audyt zależności

`composer outdated`

Pakiety z nowszymi wersjami

Planowanie aktualizacji

`composer audit`

Sprawdza znane podatności CVE

Security check przed deploy

## Semantic Versioning — jak określać wersje

Composer używa **SemVer** (MAJOR.MINOR.PATCH) z operatorami constraintów:

Constraint

Znaczenie

Przykład

`^3.0`

Compatible release (>=3.0, <4.0)

Bezpieczne dla większości bibliotek

`~3.2`

Reasonably close (>=3.2, <4.0)

Podobne do ^, ale starszy zapis

`3.2.*`

Dokładna wersja minor (>=3.2, <3.3)

Dla stabilnych API

`>=3.0 <4.0`

Zakres jawny

Gdy ^ nie wystarczy

`3.2.1`

Dokładna wersja

Unikaj — blokuje aktualizacje bezpieczeństwa

## Autoloading PSR-4

Po zdefiniowaniu mapowania w `composer.json`, plik `vendor/autoload.php` automatycznie ładuje klasy:

```
<?php
require_once __DIR__ . '/vendor/autoload.php';

// Klasa App\Services\MailService
// Plik: src/Services/MailService.php
$mailer = new App\Services\MailService();
```

Struktura katalogów dla mapowania `"App\\": "src/"`:

```
projekt/
├── src/
│   ├── Services/
│   │   └── MailService.php      # namespace App\Services;
│   ├── Models/
│   │   └── User.php             # namespace App\Models;
│   └── Controllers/
│       └── HomeController.php   # namespace App\Controllers;
├── vendor/
├── composer.json
└── composer.lock
```

## install vs update — kluczowa różnica

**ZASADA: na serwerze produkcyjnym zawsze używaj `composer install`**, nigdy `composer update`.

-   `composer install` — instaluje DOKŁADNIE wersje z `composer.lock`. Gwarantuje reproducible build — na każdym serwerze te same wersje.
-   `composer update` — rozwiązuje zależności od nowa, może pobrać nowsze wersje. Aktualizuje `composer.lock`. Ryzyko: nowa wersja może złamać coś w produkcji.

```
# Na produkcji zawsze:
composer install --no-dev --optimize-autoloader

# --no-dev: pomija pakiety require-dev (phpunit, phpstan itp.)
# --optimize-autoloader: generuje classmap zamiast PSR-4 scan — szybsze
```

## Przydatne opcje dla deploymentu

```
# Produkcja — bez devdeps, zoptymalizowany autoloader
composer install --no-dev --optimize-autoloader --no-interaction

# Sprawdź przed instalacją (dry run)
composer install --dry-run

# Bez pobierania plików (tylko sprawdzenie)
composer validate

# Wyczyść cache Composera (gdy problemy z pobieraniem)
composer clear-cache
```

## Prywatne repozytoria i Packagist

```
# composer.json — prywatne repo VCS (GitHub/GitLab)
{
    "repositories": [
        {
            "type": "vcs",
            "url": "https://github.com/firma/prywatne-repo"
        }
    ],
    "require": {
        "firma/prywatne-repo": "^1.0"
    }
}
```

```
# Autentykacja — zapisz token GitHub
composer config --global github-oauth.github.com TOKEN

# Lub przez zmienną środowiskową
COMPOSER_AUTH='{"github-oauth":{"github.com":"TOKEN"}}' composer install
```

## Powiązane strony

-   [PHP OPcache — konfiguracja](/baza-wiedzy/php-opcache-konfiguracja)
-   [PHP-FPM konfiguracja i optymalizacja](/baza-wiedzy/php-fpm-konfiguracja-optymalizacja)
-   [Laravel na hostingu](/baza-wiedzy/laravel-na-hostingu)
-   [Git deploy na hosting](/baza-wiedzy/git-deploy-hosting)
-   [Porównanie hostingów z PHP 8.x](/hosting)