[[Vorlage(Getestet, bionic, focal)]]

{{{#!vorlage Wissen
[:Pakete installieren: Installation von Programmen]
[:Terminal: Ein Terminal öffnen]
[:mit Root-Rechten arbeiten:]
[:PHP:PHP installieren und nutzen]
[:Editor: Einen Editor öffnen]
}}}

[[Inhaltsverzeichnis(2)]]

[[Bild(./logo-composer-transparent-120x147.png, 100x100, align=left)]]Composer (engl. für Musikkomponist) ist ein [wikipedia:Paketverwaltung:Paketverwaltungssystem] für die Programmiersprache [:PHP:]. Er vereinfacht und standardisiert die Installation von PHP-Bibliotheken und organisiert ihre Abhängigkeiten und Aktualisierungen. Composer ist in der PHP-Welt sehr populär, wird von namhaften Projekten wie dem [:Zend-Framework:] verwendet und hat über 200.000 Pakete im Angebot (Stand 2020). Im Gegensatz zu dem etwas in die Jahre gekommen PHP-Paket-Manager PEAR, der den PHP-Entwickler quasi dazu zwingt, die PHP-Bibliotheken einmalig systemweit zu installieren, organisiert Composer alle Pakete und Abhängigkeiten für jedes einzelne PHP-Projekt neu und unabhängig voneinander. Composer folgt damit den Konzept moderner Paket-Manager anderer Skriptsprachen, wie zum Beispiel npm für [:Node.js:] oder Bundler für [:Ruby:]. 


= Installation =
== Aus den Paketquellen ==
Composer ist seit Ubuntu 16.04 in den Paketquellen enthalten und wird über folgendes Paket installiert:

{{{#!vorlage Paketinstallation
composer, universe
}}}


== Manuelle Installation ==
Legt man Wert auf die aktuellste Version von Composer, so empfiehlt sich die manuelle Installation.

[[Vorlage(Fremd, Software)]]

=== Voraussetzungen ===
Für die manuelle Installation wird die [:PHP:]-Erweiterung '''php-cli''' benötigt.

{{{#!vorlage Paketinstallation
php-cli
}}} 
=== Installationsschritte === 

Composer stellt ein eigenes Installationsskript zur Verfügung, das man herunterladen, verifizieren und dann ausführen kann. Zunächst am besten ins Heimverzeichnis wechseln und den Installer herunterladen:

{{{#!vorlage Befehl
cd ~
wget -qO composer-setup.php https://getcomposer.org/installer 
}}}
Nun per Prüfsumme (SHA-384 Hash) verifizieren, ob die heruntergeladenen Datei wirklich fehlerfrei und in Ordnung ist. Dazu die aktuelle Signatur auf der [https://composer.github.io/pubkeys.html offiziellen Seite] {en} direkt unter der Überschrift ''„Installer Signature (SHA-384)“'' (hat eine Länge von 384 Zeichen) herauskopieren und wie folgt verifizieren:

{{{#!vorlage Befehl
COMPOSER_HASH=HIER-DEN-HASH-KEY-EINFÜGEN
php -r "if (hash_file('SHA384', 'composer-setup.php') === '$COMPOSER_HASH') { echo 'Installationsskript ist in Ordnung.'; } else { echo 'ACHTUNG: Das Installationsskript ist FEHLERHAFT.'; unlink('composer-setup.php'); } echo PHP_EOL;"
}}}
Anstatt ''HIER-DEN-HASH-KEY-EINFÜGEN'' bitte den herauskopierten Hash-Schlüssel einfügen.


Es sollte nun
{{{
Installationsskript ist in Ordnung.
}}}
ausgegeben worden sein.

Falls
{{{
ACHTUNG: Das Installationsskript ist FEHLERHAFT.
}}}

erscheint, wird die Installation abgebrochen und das fehlerhafte Installationsskript automatisch aus Sicherheitsgründen gelöscht. Bitte von vorne beginnen werden und das Installationsskript von Composer erneut herunterladen. Bitte überprüfen, ob man auch wirklich den korrekten Hash-Wert verwendet hat.

Wenn die Hash-Wert-Überprüfung erfolgreich war und man nun Composer systemweit installieren will, bitte folgenden Befehl ausführen:
{{{#!vorlage Befehl
sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer
}}}
=== Aktualisierung ===
Composer wird bei einer manuellen Installation nicht automatisch mit Updates versorgt. Um eine neuere Version zu erhalten, kann man genauso vorgehen wie bei einer Erstinstallation. Oder noch einfacher, man nutzt den Composer-eigenen Befehl:
{{{#!vorlage Befehl
sudo composer self-update
}}}

=== Deinstallation ===
Um eine manuelle Installation zu deinstallieren, muss lediglich die Datei '''/usr/local/bin/composer''' gelöscht werden. Weiterhin wurden noch Einstellungen im Home-Verzeichnis angelegt, die man bei einer vollständigen Deinstallation ebenfalls entfernen kann - siehe Unterabschnitt [#Wo-sich-die-Benutzereinstellungen-befinden Wo sich die Benutzereinstellungen befinden].

== Installation überprüfen ==
Unabhängig davon, für welche Installationsmethode man sich entschieden hat, kann wie folgt überprüft werden, ob die Installation erfolgreich war:
{{{#!vorlage Befehl
composer
}}}

Sollte bei der manuellen Installation die Fehlermeldung
{{{
bash: /usr/bin/composer: Datei oder Verzeichnis nicht gefunden
}}}
erscheinen. So muss der Befehl
{{{#!vorlage Befehl
hash composer
}}}
ausgeführt werden.

Es sollte die installierte Version und Informationen zu Composer erscheinen:

{{{
   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 1.10.7 2020-06-03 10:03:56

Usage:
  command [options] [arguments]

Options:
  -h, --help                     Display this help message
  -q, --quiet                    Do not output any message
  -V, --version                  Display this application version
      --ansi                     Force ANSI output
      --no-ansi                  Disable ANSI output
  -n, --no-interaction           Do not ask any interactive question
      --profile                  Display timing and memory usage information
      --no-plugins               Whether to disable plugins.
  -d, --working-dir=WORKING-DIR  If specified, use the given directory as working directory.
      --no-cache                 Prevent use of the cache
  -v|vv|vvv, --verbose           Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Available commands:
...
}}}

Hat man Composer manuell installiert, so sollte man nun die zuvor heruntergeladene Datei '''composer-setup.php''' löschen.
== Wo sich die Benutzereinstellungen befinden ==
Hat man als Ubuntuuser Composer genutzt, werden folgende Verzeichnisse im Heimverzeichnis angelegt. Das zu wissen kann hilfreich sein, wenn man seine Einstellungen zurücksetzen will, beziehungsweise ein Deinstallation vollständig durchführen will.
=== Bei einer Installation aus den Paketquellen ===
 * '''~/.config/composer'''
 * '''~/.local/share/composer'''
 * '''~/.cache/composer'''

=== Bei einer manuellen Installation ===
 * '''~/.composer'''
 * '''~/.cache/composer'''
= Composer benutzen =
Jedes PHP-Projekt, für das man Composer verwenden möchte, braucht eine Datei namens  `composer.json`, die in der obersten Ebene des jeweiligen Projektes vorhanden sein muss, zum Beispiel:

`/var/www/mein-tolles-projekt/composer.json`

Am besten legt man diese Datei nicht selber an, sondern lässt sie vom Composer „komponieren“ – sofern Composer wie oben beschrieben korrekt installiert ist. Dies geschieht üblicherweise, wenn man ein Composer-Paket innerhalb des eigenen PHP-Projektes installiert.

== Ein Paket installieren ==

Eine Composer-Paket-Bezeichnung besteht normalerweise aus dem Namen des Paketbetreuers, ''vendor'' genannt, und des Paketnamens. Ein Beispiel:

Angenommenen, man möchte das Programm ''ZendMail'' von [:Zend-Framework:] (einen Mailer für PHP) für sein eigenes Projekt installieren, benötigt man zunächst die genaue Paketbezeichnung. Wie man die Paketbezeichnung heraus findet, wird weiter unten erklärt. Für ''ZendMail'' lautet die korrekte Paketbezeichnung ''zendframework/zend-mail''. Nun gibt man auf der Konsole im gewünschten Projektverzeichnis lediglich:
{{{#!vorlage Befehl
composer require zendframework/zend-mail
}}}
ein. 

'''Was nun geschieht:'''
 * Composer gibt auf der Konsole aus:
{{{
Using version ^2.10 for zendframework/zend-mail
./composer.json has been created
Loading composer repositories with package information
Updating dependencies (including require-dev)
Package operations: 9 installs, 0 updates, 0 removals
  - Installing symfony/polyfill-mbstring (v1.11.0): Loading from cache
  - Installing true/punycode (v2.1.1): Loading from cache
  - Installing psr/container (1.0.0): Loading from cache
  - Installing container-interop/container-interop (1.2.0): Loading from cache
  - Installing zendframework/zend-stdlib (3.2.1): Loading from cache
  - Installing zendframework/zend-validator (2.12.0): Loading from cache
  - Installing zendframework/zend-mime (2.7.1): Loading from cache
  - Installing zendframework/zend-loader (2.6.0): Loading from cache
  - Installing zendframework/zend-mail (2.10.0): Loading from cache
... usw
}}}
 * Es wurde die Datei `composer.json` im aktuellen Arbeitsverzeichnis angelegt.
 * Das Verzeichnis `vendor/` wurde erstellt. Dort wiederum wurde folgendes neu erstellt:
  * Die Datei `autoload.php`. Sie muss im Projekt für das automatische Laden eingebunden werden (''Autoloading'') - siehe unten.
  * Das Unterverzeichnis `composer/`. Es regelt das automatische Laden aller per Composer installierten Pakete.
  * Das Unterverzeichnis `zend-framework/` - die ist die Bezeichnung des Paketbetreuers (''vendor'') von ''ZendMail'' - hierin befindet sich das eigentlich Paket: ''zend-mail/''.
  * Neben `zend-framework/` wurden hier noch alle Abhängigkeiten in weiteren Unterverzeichnissen mit installiert - eine der wichtigsten Funktionen von Composer.
  
== Pakete einbinden ==
In dem Skript, in dem man die mittels Composer installierte Bibliothek nutzen möchte, bindet man nun die von Composer erstellte Datei `vendor/autoload.php` ein und schon hat man mittels [https://www.php.net/manual/de/language.namespaces.basics.php Namensräumen] {de} Zugriff auf sämtliche mittels Composer installierten Klassen. In unserem Beispiel mit ''ZendMail'' könnte unser PHP-Skript folgendermaßen aussehen:
{{{#!code php
<?php
// Composer autoloading.
// Wir gehen davon aus, dass dieses Skript sich eine Ebene über
// den von Composer erstellten vendor-Verzeichnis befindet
include __DIR__ . '/vendor/autoload.php';

//Die Komponenten, die gebraucht werden, per Namespaces einbinden.
// In unserem Beispiel:
use Zend\Mail;

//Jetzt kann es losgehen und ZendMail verwendet werden:
$mail = new Mail\Message();
$mail->setBody('Hallo, lieber Ubuntuuser!');
$mail->setFrom('I.Bims@example.org', "Max Mustermann");
$mail->addTo('Kevin@example.com', 'Name des Empfängers');
$mail->setSubject('Betreff: Ich nutze jetzt Composer!');

// ... usw.
}}}

= Befehle und Optionen =
Composer '''Befehle''' werden mit `composer` und einem Leerzeichen eingeben:
{{{#!vorlage Befehl
composer <Befehl>
}}}
'''Optionen''' werden mit `composer`, einem Leerzeichen und einem bzw. zwei Bindestrichen eingeben:
{{{#!vorlage Befehl
composer [--Option]
composer [-Optionskürzel]
}}}

Zu den meisten Befehlen gibt es zudem noch eigene Optionen.

== Projektbezogene Befehle ==
Folgende Befehle bzw. Optionen dienen der Verwaltung des jeweiligen Projektes, in welchem man Composer ausführt. Dazu muss man Composer in dem Verzeichnis des Projektes ausführen, in dem sich die `composer.json` befindet. Üblicherweise ist dies die oberste Verzeichnisebene des jeweiligen Projektes. Eine Ausnahme bildet der Befehl `require`. Ist noch keine `composer.json` Datei in einem (neuem) Projekt-Verzeichnis vorhanden, so wird sie erstellt.
{{{#!vorlage Tabelle
<tableclass="zebra_start2" rowclass="kopf">Befehl
Beschreibung
+++
`install`
Liest die `composer.json`-Datei im aktuellen Arbeitsverzeichnis aus, löst alle Abhängigkeiten auf und installiert sie ins `vendor`-Verzeichnis.
+++
`require <Paketbetreuer/Paket>`
Fügt neue Abhängigkeiten zur `composer.json` hinzu bzw. erstellt die `composer.json` neu. Anschließend wird das neue Paket und seine Abhängigkeiten ins Vendor-Verzeichnis installiert.
+++
`create-project <Paketbetreuer/Projekt>`
Erstellt ein neues Projekt aus einer verfügbaren Paketquelle. Entspricht: `git clone Paketbetreuer/Projekt`.
+++
`suggests`
Listet alle Installationsempfehlungen aller Pakete auf.
+++
`outdated`
Gibt eine Liste der möglichen Aktualisierungen des jeweiligen Projektes aus.
+++
`update` (alias: `upgrade`)
Aktualisiert alle Abhängigkeiten auf die neuste Version. Vergleichbar mit [:apt/apt-get/#apt-get-upgrade:apt-get upgrade] in Ubuntu.
+++
`remove <Paketbetreuer/Paket>`
Entfernt den Abhängigkeitseintrag für das angegeben Paket  aus der `composer.json` und deinstalliert es aus dem `vendor`-Verzeichnis.
}}}


== Globale Optionen ==
Diese Optionen können zu jedem Composer-Befehl mit eingegeben werden. Die Syntax lautet dabei:
{{{#!vorlage Befehl
composer <Befehl> [--Option]
composer <Befehl> [-Optionskürzel]
}}}


{{{#!vorlage Tabelle
<tableclass="zebra_start2" rowclass="kopf">Option
Beschreibung
+++
`--version | -V`
Version anzeigen.
+++
`--working-dir <Verzeichnis>| -d <Verzeichnis>`
Verwendet ` <Verzeichnis>` als Arbeitsverzeichnis (nutzt oder erstellt die dortige `composer.json`).
+++
`--no-cache`
Cache deaktivieren.
+++
`--no-interaction | -n`
Nutzt bei Interaktionen die jeweilige Default-Option und stellt dabei (fast) keine Fragen.
+++
`--verbose | -v`
Vollständige Ausgabe aller Informationen. (Standard) 
+++
`--help | -h`
Kurzhilfe anzeigen.
}}}

'''Beispiel:'''
{{{#!vorlage Befehl
composer require symfony/console -d /var/www/lib/meine-tools/
}}}
Hier werden die [https://symfony.com/doc/current/components/console.html Konsolen-Werkzeuge] {en} des PHP-Frameworks ''Symfony'' in das Verzeichnis `/var/www/lib/meine-tools/` installiert.  


Eine ausführliche Übersicht aller Befehle und Optionen findet man auf der [https://getcomposer.org/doc/03-cli.md offiziellen Dokumentationsseite] {en} des Projektes.


= Pakete finden =
Hat man ein PHP-Composer-Paket gefunden, das man nutzen möchte, benötigt man die genau Bezeichnung. Diese folgt dem selben Muster wie auf [https://github.com/ Github] {en}:

`Paketbetreuer-Name/Paketname`

Möglich sind auch Unterprojekte mit mehren Ebenen:

`Paketbetreuer-Name/Paketname/Unterpaket`

Meistens geben die Paketbetreuer diese Paketnamen auf Ihren jeweiligen Projektseiten an. Mit [https://packagist.org/ Packagist] {en} gibt es aber auch ein umfassendes Paket-Verzeichnis (Repository). Packagist ist das offizielle Verzeichnis von Composer und bietet Suchfunktionen an, mit denen man gewünschte Pakete gezielt finden kann. Mit einem Blick ist ersichtlich, wie oft das jeweilige Paket bereits installiert wurde (''Installs'') und wie viele Sterne (''Stars'') es hat - also die Bewertungen, die das Paket auf Github erhalten hat.

= Pakete aktualisieren = 
Composer selbst bietet zwar Funktionen an, die einem Informationen über mögliche Updates für installierte PHP-Bibliotheken liefert und um die Updates durchzuführen. Es gibt jedoch weder ein automatisches Benachrichtigungssystem über vorhandene Updates, noch kann man mögliche Aktualisierungen in regelmäßigen Intervallen selbständig durchführen lassen - auch nicht für wichtige Sicherheitsaktualisierungen. Zudem sind Updates nur für jeweils ein Projekt möglich, also pro vorhandener `composer.json`-Datei. Dies mag etwas ungewohnt sein, wenn man beispielsweise an die Paketverwaltung von Ubuntu gewöhnt ist und man muss eigene Strategien implementieren, um bei (Sicherheits-)Aktualisierungen auf dem Laufenden zu sein.

Befindet man sich in dem Verzeichnis, in dem sich die `composer.json`-Datei seines Projektes befindet, kann man Updates wie folgt durchführen:
{{{#!vorlage Befehl
composer outdated
}}}
Dieser Befehl zeigt zunächst nur verfügbare Updates an, führt aber noch keine Aktualisierung durch.

{{{#!vorlage Befehl
composer update --dry-run
}}}
Zunächst `composer update --dry-run` auszuführen ist sinnvoll, um vorab zu testen, wie der Update-Vorgang abliefe und ob sich unter Umständen Abhängigkeitsprobleme ergäben.

Möchte man nunmehr das eigentliche Update durchführen, gibt man folgenden Befehl ein:
{{{#!vorlage Befehl
composer update
}}}

All dies Schritte sind auch nur für ein ausgewähltes Pakt möglich:
{{{#!vorlage Befehl
composer update <Paketbetreuer/Paket>
}}}

Oder, falls man alle installierten Pakte eines Paketbetreuer updaten will:
{{{#!vorlage Befehl
composer update <Paketbetreuer/*>
}}}

Mit:
{{{#!vorlage Befehl
composer update <Paketbetreuer/Paket> --with-dependencies
}}}
werden zudem auch die Abhängigkeiten des zu aktualisierenden Paketes mit aktualisiert.

= Grafische Oberflächen (GUI) =
Composer ist für die Bedienung auf der Kommandozeile ausgelegt und es gibt keine offizielle GUI. Wer dennoch Composer mittels einer GUI bedienen will, hat inzwischen eine Reihe von Möglichkeiten:

== Per IDE ==
Einige [:Entwicklungsumgebungen:] (IDEs) bieten recht komfortable grafische Bedienelemente, um die `composer.json`-Datei zu verwalten. Zum Beispiel:

=== Eclipse mit PDT ==
[:Eclipse:] hat mit der Erweiterung [https://www.eclipse.org/pdt/ PHP Development Tools] {en} ein umfangreiches Werkzeug mit im Programm, um fast alle Modifikationen an einem Composer-Projekt vorzunehmen. Das GUI-Fenster für Composer, das für eine bessere Übersicht in mehrere Reiter aufgegliedert ist, bietet sogar eine integrierte Suchfunktion für Packagist, mit der man neue Pakete installieren kann. Sobald man die `composer.json` innerhalb von Eclipse per Doppel-Klick öffnet, wird die GUI gestartet.

{{{#!vorlage Tabelle
<:>[[Bild(eclipse-composer-0.png, x250)]]
<:>[[Bild(eclipse-composer-1.png, x250)]]
+++
<:>Paketverwaltung in Eclipse mit Packagist Suchfenster
<:>Abhängigkeitein-Graph in Eclipse
}}}

 
=== Netbeans ===
Auch für [:Netbeans:] gibt es die Möglichkeit, Composer per Benutzeroberfläche zu bearbeiten. In einem [https://blogs.oracle.com/netbeansphp/composer-support Blog-Artikel von Oracle] {en}, einem der Sponsoren von Netbeans,  gibt es hierzu weitere Informationen.


== Composercat ==
[https://getcomposercat.com/ Composercat ] {en} bietet [:Paketinstallation_DEB:DEB]-Pakete zur Installation an. Das Projekt befindet sich noch in der Beta-Phase, ist aber bereits gut zu gebrauchen. Allerdings stammt die letzte Version aus Juli 2017 und die Software scheint nicht mehr weiterentwickelt zu werden.

[[Vorlage(Fremd, Paket)]]

= Links =
 * [https://getcomposer.org/ Offizielle Projektseite] {en}
 * [https://packagist.org/ Packagist] - offizielles Verzeichnis aller Pakete {en}
 * [github:composer/composer:Composer auf Github] {en}

#tag: PHP, Webanwendung, Installation, Server, Programmierung, Composer