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

# Prozesse

> Wie Sie mit der Process-Fassade von Laravel externe Shell-Kommandos ausführen und dabei synchron, asynchron und parallel arbeiten.

## Einführung

Die Process-Fassade von Laravel ist ein schlanker Wrapper um die [Symfony-Process-Komponente](https://symfony.com/doc/current/components/process.html).
Sie bietet eine knappe API, um aus einer Laravel-Anwendung heraus Shell-Kommandos aufzurufen und deren Ergebnisse zu verarbeiten.

```mermaid theme={null}
flowchart LR
    A["Laravel-Anwendung"] --> B["Process-<br>Fassade"]
    B --> C["Shell-Kommando"]
    C --> D["ProcessResult<br>(output / exitCode)"]
    D --> A
```

## Prozesse starten

Mit `Process::run()` führen Sie ein Kommando synchron aus und erhalten das Ergebnis.

```php theme={null}
use Illuminate\Support\Facades\Process;

$result = Process::run('ls -la');

return $result->output();
```

Die `ProcessResult`-Instanz stellt verschiedene Methoden bereit, um das Ergebnis zu prüfen.

```php theme={null}
$result = Process::run('ls -la');

$result->command();       // Ausgeführtes Kommando
$result->successful();    // Erfolgreich? (Exit-Code 0)
$result->failed();        // Fehlgeschlagen? (Exit-Code ungleich 0)
$result->output();        // Standardausgabe (stdout)
$result->errorOutput();   // Fehlerausgabe (stderr)
$result->exitCode();      // Exit-Code
```

### Bei Fehler eine Exception werfen

Um bei einem Exit-Code größer als 0 die Ausnahme `Illuminate\Process\Exceptions\ProcessFailedException` auszulösen, verwenden Sie `throw()` bzw. `throwIf()`.

```php theme={null}
$result = Process::run('ls -la')->throw();

$result = Process::run('ls -la')->throwIf($condition);
```

## Prozessoptionen

### Arbeitsverzeichnis

Mit `path()` geben Sie das Arbeitsverzeichnis an. Ohne Angabe wird das aktuelle Arbeitsverzeichnis des PHP-Skripts verwendet.

```php theme={null}
$result = Process::path(__DIR__)->run('ls -la');
```

### Standardeingabe

Mit `input()` übergeben Sie Daten an die Standardeingabe des Prozesses.

```php theme={null}
$result = Process::input('Hello World')->run('cat');
```

### Timeout

Standard sind 60 Sekunden. Mit `timeout()` ändern Sie den Wert. Bei einem Timeout wird der Prozess abgebrochen und `ProcessTimedOutException` geworfen.

```php theme={null}
$result = Process::timeout(120)->run('bash import.sh');
```

Auch die `CarbonInterval`-Helferfunktionen sind nutzbar.

```php theme={null}
use function Illuminate\Support\minutes;

$result = Process::timeout(minutes(2))->run('bash import.sh');
```

Um das Timeout ganz zu deaktivieren, verwenden Sie `forever()`.

```php theme={null}
$result = Process::forever()->run('bash import.sh');
```

Sie können auch ein Idle-Timeout festlegen (Sekunden ohne Ausgabe).

```php theme={null}
$result = Process::timeout(60)->idleTimeout(30)->run('bash import.sh');
```

### Umgebungsvariablen

Mit `env()` fügen Sie Umgebungsvariablen hinzu oder überschreiben sie. Die Systemvariablen werden automatisch geerbt.

```php theme={null}
$result = Process::forever()
    ->env(['IMPORT_PATH' => __DIR__])
    ->run('bash import.sh');
```

Um eine geerbte Variable auszuschließen, setzen Sie sie auf `false`.

```php theme={null}
$result = Process::forever()
    ->env(['LOAD_PATH' => false])
    ->run('bash import.sh');
```

### Ausgabe unterdrücken

Wenn große Ausgaben nicht benötigt werden, sparen Sie mit `quietly()` Speicher.

```php theme={null}
$result = Process::quietly()->run('bash import.sh');
```

### Ausgabe in Echtzeit

Übergeben Sie `run()` eine Closure als zweites Argument, erhalten Sie die Ausgabe in Echtzeit.

```php theme={null}
$result = Process::run('ls -la', function (string $type, string $output) {
    echo $output;
});
```

## Pipelines

Mit `Process::pipe()` verknüpfen Sie die Ausgabe eines Kommandos mit der Eingabe des nächsten.

```php theme={null}
use Illuminate\Process\Pipe;
use Illuminate\Support\Facades\Process;

$result = Process::pipe(function (Pipe $pipe) {
    $pipe->command('cat example.txt');
    $pipe->command('grep -i "laravel"');
});

if ($result->successful()) {
    // ...
}
```

Sie können auch ein Array mit Kommando-Strings übergeben.

```php theme={null}
$result = Process::pipe([
    'cat example.txt',
    'grep -i "laravel"',
]);
```

Wenn Sie jedem Prozess mit `as()` einen Schlüssel geben, können Sie in der Ausgabe-Closure erkennen, welcher Prozess die Ausgabe erzeugt hat.

```php theme={null}
$result = Process::pipe(function (Pipe $pipe) {
    $pipe->as('first')->command('cat example.txt');
    $pipe->as('second')->command('grep -i "laravel"');
}, function (string $type, string $output, string $key) {
    // $key ist entweder 'first' oder 'second'
});
```

## Asynchrone Prozesse

Mit `Process::start()` starten Sie einen Prozess asynchron. Während der Prozess läuft, kann die Anwendung anderen Aufgaben nachgehen.

```php theme={null}
$process = Process::timeout(120)->start('bash import.sh');

while ($process->running()) {
    // Weitere Arbeit
}

$result = $process->wait();
```

### Prozess-ID und Signale

Mit `id()` erhalten Sie die Prozess-ID des laufenden Prozesses.

```php theme={null}
$process = Process::start('bash import.sh');

return $process->id();
```

Mit `signal()` senden Sie ein Signal an den Prozess.

```php theme={null}
$process->signal(SIGUSR2);
```

### Ausgabe eines asynchronen Prozesses

Während der Ausführung liefern `latestOutput()` und `latestErrorOutput()` die seit dem letzten Abruf entstandene Ausgabe.

```php theme={null}
$process = Process::timeout(120)->start('bash import.sh');

while ($process->running()) {
    echo $process->latestOutput();
    echo $process->latestErrorOutput();

    sleep(1);
}
```

Um zu warten, bis eine bestimmte Ausgabe erscheint, verwenden Sie `waitUntil()`.

```php theme={null}
$process = Process::start('bash import.sh');

$process->waitUntil(function (string $type, string $output) {
    return $output === 'Ready...';
});
```

### Timeout in asynchronen Prozessen prüfen

Rufen Sie in Schleifen `ensureNotTimedOut()` auf, um bei einem Timeout eine Exception zu erhalten.

```php theme={null}
$process = Process::timeout(120)->start('bash import.sh');

while ($process->running()) {
    $process->ensureNotTimedOut();

    sleep(1);
}
```

## Parallele Prozesse

Mit `Process::pool()` führen Sie mehrere Prozesse parallel aus.

```php theme={null}
use Illuminate\Process\Pool;
use Illuminate\Support\Facades\Process;

$pool = Process::pool(function (Pool $pool) {
    $pool->path(__DIR__)->command('bash import-1.sh');
    $pool->path(__DIR__)->command('bash import-2.sh');
    $pool->path(__DIR__)->command('bash import-3.sh');
})->start(function (string $type, string $output, int $key) {
    // ...
});

while ($pool->running()->isNotEmpty()) {
    // ...
}

$results = $pool->wait();
```

Mit `concurrently()` schreiben Sie „Pool sofort starten und auf Ergebnisse warten“ in einer Zeile.

```php theme={null}
[$first, $second, $third] = Process::concurrently(function (Pool $pool) {
    $pool->path(__DIR__)->command('ls -la');
    $pool->path(app_path())->command('ls -la');
    $pool->path(storage_path())->command('ls -la');
});

echo $first->output();
```

### Prozessen Namen geben

Mit `as()` weisen Sie jedem Prozess einen String-Schlüssel zu, sodass Ergebnisse eindeutig zugänglich sind.

```php theme={null}
$pool = Process::pool(function (Pool $pool) {
    $pool->as('first')->command('bash import-1.sh');
    $pool->as('second')->command('bash import-2.sh');
    $pool->as('third')->command('bash import-3.sh');
})->start(function (string $type, string $output, string $key) {
    // ...
});

$results = $pool->wait();

return $results['first']->output();
```

Sie können auch an den gesamten Pool ein Signal senden.

```php theme={null}
$pool->signal(SIGUSR2);
```

## Tests

### Prozesse faken

Mit `Process::fake()` testen Sie, ohne dass echte Shell-Kommandos ausgeführt werden.

```php theme={null}
use Illuminate\Support\Facades\Process;

Process::fake();

$response = $this->get('/import');

Process::assertRan('bash import.sh');
```

Ausgabe und Exit-Code lassen sich vorgeben.

```php theme={null}
Process::fake([
    '*' => Process::result(
        output: 'Test output',
        errorOutput: 'Test error output',
        exitCode: 1,
    ),
]);
```

### Bestimmte Kommandos faken

Über Wildcards oder konkrete Kommando-Strings als Schlüssel legen Sie individuelle Fakes fest.

```php theme={null}
Process::fake([
    'cat *'    => Process::result(output: 'file contents'),
    'ls -la'   => Process::result(output: 'file listing'),
]);
```

### Sequenzen faken

Wenn dasselbe Kommando mehrfach aufgerufen wird, geben Sie die Reihenfolge der Ergebnisse an.

```php theme={null}
Process::fake([
    'ls *' => [
        Process::result('first time'),
        Process::result('second time'),
    ],
]);
```

### Assertions

| Methode                                 | Beschreibung                                    |
| --------------------------------------- | ----------------------------------------------- |
| `Process::assertRan('command')`         | Prüft, dass ein Kommando ausgeführt wurde       |
| `Process::assertNotRan('command')`      | Prüft, dass ein Kommando nicht ausgeführt wurde |
| `Process::assertRan(fn)`                | Detaillierte Prüfung über eine Closure          |
| `Process::assertRanTimes('command', 3)` | Prüft, dass ein Kommando N-mal ausgeführt wurde |

### Unerwartete Prozesse verhindern

Mit `Process::preventStrayProcesses()` wird eine Exception geworfen, sobald ein Kommando ausgeführt wird, für das kein Fake definiert wurde.

```php theme={null}
Process::preventStrayProcesses();

Process::fake([
    'ls *' => Process::result('file listing'),
]);

// Exception: für 'bash import.sh' ist kein Fake definiert
Process::run('bash import.sh');
```

## Verwandte Seiten

<Columns cols={2}>
  <Card title="Artisan-Konsole" icon="terminal" href="/de/artisan">
    Eigene Kommandos erstellen und Prozesse aufrufen
  </Card>

  <Card title="Queues" icon="list" href="/de/queues">
    Vergleich zu asynchroner Verarbeitung
  </Card>
</Columns>


## Related topics

- [WebSocket (Jetstream / Firehose)](/de/packages/laravel-bluesky/websocket.md)
- [Cache](/de/cache.md)
- [Einstieg in Tests](/de/testing.md)
- [Queues und Jobs](/de/queues.md)
- [Laravel Horizon](/de/horizon.md)