7 einfache Schritte zu Satis - TYPO3 Privatpakete für Entwickler

Als wir unser t3planet.com-Projekt starteten, war eine der ersten Superforderungen unserer Kunden der "Support Composer" auch für hochwertige TYPO3-Produkte. Da die TYPO3-Leute den Composer einfach lieben, hat die Community auch einen eigenen Composer-Server https://composer.typo3.org/

7 einfache Schritte zu Satis - TYPO3 Privatpakete für Entwickler

FYI. This blog is translated by machine. Please ignore any spelling and grammar errors; sorry for such inconvenience. We appreciate your understanding and support.

Als wir unser t3planet.com venture starteten, war eine der ersten Superforderungen unserer Kunden der "Support Composer" auch für Premium-TYPO3-Produkte.

Da die TYPO3-Leute den Composer einfach lieben, hat die Community auch einen eigenen composer-server https://composer.typo3.org/

Und, wissen Sie, wir lernen immer viel aus der Nachfrage und dem Feedback unserer Kunden.

Die kostenlosen TYPO3-Produkte von T3Planet haben bereits Komponistenunterstützung mit den beliebtesten Packagist.org Bei einem Premium-Paket war es jedoch immer noch eine manuelle Installation.

Team T3Planet nahm die Herausforderung an und freute sich riesig, TYPO3 Satis Private Pakete für den Composer zu erstellen.

Eine Sache noch, manier Male hätten Sie bemerkt, dass packagist.org sehr langsam ist, wenn Sie Ihre TYPO3-Pakete über composer installieren und aktualisieren. Wir empfehlen die Einrichtung Ihres privaten Composer-Servers, um produktiv arbeiten zu können.

Wir hatten ein wachsendes Problem: Jedes Mal, wenn wir etwas auf GIT drückten, brauchte die CI mehr als fünf Minuten, um eine neue Version bereitzustellen.

Bevor Sie beginnen: Wenn Sie nicht wissen, was ein Komponist ist? Dann googlen Sie "PHP Composer" ;) und Sie werden es lieben, ihn zu erforschen. Denn so arbeiten moderne PHP-Entwickler heutzutage!

Wo liegt das Problem?

Die beiden PHP-Entwickler Nils und Jordi haben diese coole Paketmanager-Lösung auf PHP-Anwendungsebene entwickelt, um die Art und Weise zu ändern, wie Entwickler PHP-Pakete, z. B. TYPO3-Erweiterungen, installieren - Call Composer.

Packagist.org ist das Haupt-Repository zur Anbindung Ihrer TYPO3-Pakete.

Aber hier liegt das eigentliche Problem, Packagist hat nur die Möglichkeit, Ihre öffentlichen OpenSource-TYPO3-Pakete zu veröffentlichen. Es enthält Tausende von PHP-Paketen.

Was ist mit Ihren privaten TYPO3-Paketen? Sie können private Pakete in Ihren privaten Git-Repositories wie Github, Gitlab, Bitbucket usw. gespeichert haben.

Wie können Sie Ihre privaten TYPO3-Pakete und Pakete Ihren Kunden oder Teams zur Verfügung stellen? Das ist ein Grund, Sie sind noch hier, um zu wissen, wie? Und natürlich, falls Sie Performance-Probleme mit packagist.org haben ;)

Wie können Sie Ihre privaten TYPO3-Pakete auf einfache Weise einrichten?

Dennoch gibt es nur zwei Möglichkeiten, Ihre privaten TYPO3-Pakete zu installieren und zu konfigurieren.

Option 1: SaaS-Lösung von Packagist.com

Diese Option ist großartig, wenn Sie ein gutes Budget für Ihre privaten Projekte haben :) Sie wurde vom gleichen Team von Packagist.org entwickelt und gewartet. Wir haben die Testversion ausprobiert und sieht vielversprechend aus mit großartigen Funktionen wie

  • Einfache Integration mit Ihren bevorzugten Git-Tools wie Github, Gitlab und Bitbucket
  • Sehr benutzerfreundliche Benutzerschnittstelle zum Hosten Ihrer privaten Repositorien
  • Viel schneller und zuverlässiger für den Einsatz
  • Zugangs- und Beschränkungsoptionen

Schließlich ist es von den Schöpfern des Komponisten gemacht!

Option 2: Selbst gehostete Lösung mit Satis

Leider gibt es nur eine gute Option, um Ihr TYPO3 Satis einzurichten. Das ist das Ziel dieses Blogs, um Sie wissen zu lassen, wie Sie Satis einrichten können.

Was ist Satis?

Nun, Satis ist ein OpenSource-Projekt für einen statischen Komponisten-Repository-Generator. Hier ist die Quelle https://github.com/composer/satis es wurde auch im offiziellen Führer unter  erwähnt;Getcomposer.org

Lassen Sie uns mit einer Schritt-für-Schritt-Anleitung für alles, wie z.B. TYPO3 einrichten, Webhooks erstellen, Sicherheit & Authentifizierung usw., wie folgt vorgehen.

Nur um Ihnen einen Eindruck zu vermitteln: Sobald Sie das gesamte Satis-Setup installiert und konfiguriert haben, erhalten Sie das endgültige Setup wie folgt.

Architektur des Packagisten

Architektur des privaten TYPO3-Composer-Servers

Schritt 1. Installation von Satis

Voraussetzungen

  1. Wir schlagen vor, eine Subdomäne wie&nbsp zu erstellen;https://composer.yourdomain.com/
  2. Composer >= 1.9
  3. PHP >= 7.2

Satis installieren

Gehen Sie zu Ihrer bevorzugten Befehlszeile und geben Sie folgenden Befehl ein

composer create-project composer/satis --stability=dev --keep-vcs

Das war's, "satis"-Ordner wurde initiiert, der alle abhängigen Module wie Symfony, composer etc. in Ihrem Stammordner enthält.

Schritt 2. Konfigurieren von satis.json

Erstellen Sie in Ihrem Stammordner satis.json und lassen Sie uns Ihre privaten Repositorys wie folgt konfigurieren.

{
    "name": "Repository Name",
    "homepage": "https://composer.yourdomain.com",
    "archive": {
        "directory": "dist",
        "absolute-directory" : "/path/to/save/packages/",
        "format": "zip",
        "skip-dev": true
    },
    "require-all": true,
    "require-dependencies": true,
    "require-dev-dependencies": false,
    "output-html": true,
    "repositories": [
        {
            "name": "vendor/package1", "type": "vcs", "url": "https://gitlab.com/vendor/package1.git" 
            },
        {
            "name": "vendor/package1", "type": "vcs", "url": "https://github.com/vendor/package2.git" 
            },
        { 
            "name": "georgringer/news", "type": "vcs", "url": "https://github.com/georgringer/news"
        }
    ],
    "require": {
        "vendor/package1": "*",
        "vendor/package2": "*"
    }
}

Das meiste des Aufbaus ist selbsterklärend, obwohl ich versuchen möchte, schnell wichtige Konfigurationsoptionen von satis.json

zu schreiben

  • absolut-Verzeichnis: Setzen Sie den aktuellen Root-Ordner so, dass er einen "dist"-Ordner innerhalb Ihrer Domain hat.
  • Anforderungsabhängigkeiten: Satis wird automatisch abhängige andere Repositorien herunterladen.
  • Ausgabe-html: Behalten Sie diese Einstellung bei, es wird eine schön formatierte index.html
  • Repositorien: Konfigurieren Sie alle Ihre privaten und öffentlichen Repositories mit Git.
  • erfordern: Von hier aus wird Satis Pakete generieren.

Schritt 3. Zufriedenheit für Komponistenpakete erzeugen

Nun sind Sie alle bereit, zufriedenstellende Pakete auf Ihrem composer-server zu bauen. Führen Sie den folgenden Befehl aus:

Syntax: php bin/satis build <configuration file> <build-dir>
Example: php satis/bin/satis build satis.json ./

Erklären Sie den Befehl:

  1. php: Ihr php-Bin-Pfad (im Allgemeinen funktioniert php global)
  2. satis bin: Wie wir den Ordner satis haben, so definieren Sie satis/bin/satis
  3. build: ist ein Befehl zum Erzeugen von Paketen
  4. satis.json: Da wir satis.json an der Wurzel
  5. konfiguriert haben
  6. Pakete Pfad: Der Pfad zur Erzeugung der Paketauflistung (mit index.html)

Wenn Sie Ihre privaten Repositories von Git-Tools konfiguriert haben, sollte es Sie nach einer Authentifizierung als Benutzername und Passwort fragen.

Es ist nur das erste Mal, dass Sie Benutzer/Pass hinzufügen müssen, es wird die Zugangsdaten unter auth.json des Komponisten für die zukünftige Verwendung speichern.

Beschränkung auf 60 Anrufe/Std.

Oh!! Sind Sie mit Limit-Fehleranrufen von Ihrem Git-Zugang aus konfrontiert wie?

Keine Sorge, springen Sie einfach zu der in der Beschreibung genannten URL und generieren Sie Token von Ihrem Git-Tool aus, um die Beschränkung auf 60 Aufrufe/Std. aufzuheben.

Generieren von Github/Gitlab-Token

Sobald der Baubefehl erfolgreich ausgeführt wurde, generiert er packages.json + dist-Ordner mit allen Paketen, die in .zip-Dateien heruntergeladen werden. Werfen Sie einen Blick auf die Struktur des "dist"-Ordners.

Gehen Sie auch zu Ihrer https://composer.yourdomain.com/index.html Sie sollten in der Lage sein, eine nette Schnittstelle mit all Ihren generierten Paketinformationen zu haben.

Schritt 4. Testlauf mit Ihren TYPO3-Privatpaketen mit Composer

Jetzt ist es an der Zeit, Ihr TYPO3 composer-basiertes Projekt zu testen.

1. Konfigurieren Sie Ihren composer.json

"repositories": [
    {
        "type": "composer",
        "url": "https://composer.yourdomain.com/"
    },
    {
        "packagist.org": false
    },
    {
        "composer.typo3.org": false
    }
],

2. composer-Installationsbefehl ausführen

composer require vendor/package-name ^1

Hurray!

Ihre satis-Pakete sollten von der neuesten Erweiterung von Ihrem Composer-Server heruntergeladen werden.

Wenn Sie irgendwelche Probleme haben, dann überprüfen Sie weitere Details, indem Sie -vvvv an Ihren Befehl übergeben.

Schritt 5. Webhook zwischen Ihren privaten TYPO3 Repositories & Satis

Natürlich ist die Geschichte noch nicht zu Ende, Sie müssen noch an ein paar weiteren Aufgaben arbeiten ;)

Jetzt sollten Sie eine Brücke bauen, um Ihre privaten TYPO3-Pakete zwischen Git & Satis. Wann immer Ihr Team etwas mit dem Git-Tool veröffentlicht, sollte es automatisch von Ihrem Satis composer Server gegrabbt werden.

Deshalb müssen Sie den sogenannten "Webhook" vorbereiten. Dazu erstellen wir ein PHP-Skript.

webhook.php

<?php
    // Set Composer home (also if not work then set to .htaccess)
    putenv("COMPOSER_HOME=/your/home/.composer");

    // Initiate Symfony
    require_once __DIR__.'/satis/vendor/autoload.php';

    use Symfony\Component\Process\Process;

    // Basic-Configuration
    $config = array(
        'bin' => '/your/path/satis/bin/satis',
        'json' => '/your/path/satis.json',
        'webroot' => '/your/path/',
        'user' => null,
        'secretykey' => 'set-your-secret-key',
    );

    // Validation Testing
    if (!file_exists($config['bin'])) {
        die('The Satis bin could not be found.');
    }

    if (!file_exists($config['json'])) {
        die('The satis.json file could not be found.');
    }

    if (!file_exists($config['webroot'])) {
        die('The webroot directory could not be found.');
    }

    // Switch to user
    if (null !== $config['user']) {
        $command = sprintf('sudo -u %s -i', $config['user']);
        exec($command);
    }

    // Option 1: For direct update from Browser can use the package get parameter to pass the repo url to update. Eg., https://composer.yourdomain.com/?package=giturl
        if(!empty($_GET['package'])){
        $command = sprintf('%s build %s %s %s', $config['bin'], '--repository-url '.htmlentities($_GET['package']), $config['json'], $config['webroot']);
    }

    // Option 2: Gitlab Webhook
    else if(!empty($_SERVER["HTTP_X_GITLAB_TOKEN"])){

        // Validate Secret Tocken
        if ($_SERVER["HTTP_X_GITLAB_TOKEN"] == $config['secretykey']) {
                $input = file_get_contents("php://input");
                $json = json_decode($input);
                if (!is_object($json)) {
                die('No valid JSON');
            }
            if ($json->object_kind == "push" || $json->object_kind == "tag_push") {
                $repoUrl = $json->repository->git_http_url;
                $command = sprintf('%s build %s %s %s', $config['bin'], '--repository-url '.$repoUrl, $config['json'], $config['webroot']);
            }
            else {
                die("Invalid Push Event from Gitlab!");
            }
        }
        else {
            die("Invalid Gitlab Secret Key!");
        }
    }

    // Option 2: Github Webhook
    else if(!empty($_SERVER["HTTP_X_HUB_SIGNATURE"])){

        // Validate Secret Tocken
        $signature = $_SERVER['HTTP_X_HUB_SIGNATURE'];

        if ($signature) {
            $hash = "sha1=".hash_hmac('sha1', file_get_contents("php://input"), $config['secretykey']);
            if (strcmp($signature, $hash) == 0) {
                $payload = json_decode($_POST['payload']);
                if (!is_object($payload)) {
                    die('No valid JSON');
                }
                $repoUrl = htmlentities($payload->repository->clone_url);
                $command = sprintf('%s build %s %s %s', $config['bin'], '--repository-url '.$repoUrl, $config['json'], $config['webroot']);
            }
            else {
                die("Invalid Github Secret Key!");
            }
        }
        else {
            die("Invalid Github Secret Key!");
        }
    }

    // Prepare Default Shell-Command eg., For daily-cron
    else {
        $command = sprintf('%s build %s %s', $config['bin'], $config['json'], $config['webroot']);
    }

    // Final command to execute
    if (!empty($command)) {
        $command = "/usr/bin/php7.2 ".$command;

        // Execute final command to build Composer-server
        $exitCode = exec($command);

        // Error-handeling
        $process = new Process($command);
        $exitCode = $process->run(function ($type, $buffer) {
            if ('err' === $type) {
                echo '<br><strong>Error:</strong> '.$buffer;
                error_log($buffer);
            } else {
                echo '.';
            }
        });

        $returnMsg = '<br><br>Satis mirror : '.($exitCode === 0 ? 'Successful rebuild '.(!empty($_GET['package']) ? ' of package '.htmlentities($_GET['package']).'.' : ' of entire index!') : ' An error occured! : '.print_r($exitCode, true));
    }
    else {
        $returnMsg = "<br>No command found!";
    }

    echo "<br>" . $returnMsg . "\n";
?>

Uuf! Bisschen langer Code, aber sehr selbsterklärend & keine Sorge, es wurde gut getestet ;)

Nun lassen Sie uns webhook.php auf Ihre Lieblings-Git-Tools einstellen. Wann immer Sie also einen Push oder Release-Tag aus Ihrem Git freigeben, wird Ihr Satis Composer-Server informiert, neue TYPO3-Pakete auf Ihrem privaten Server zu generieren.

Wie erzeugt man mit Webhook private TYPO3-Pakete?

  • Option 1: Pakete über Web-URL aktualisieren

Sie können webhook.php z.B. in Ihrem Web-Browser ausführen,

https://composer.yourdomain.com/webhook.php?package=https://github.com/vendor/package.git

Webhook wurde so konzipiert, dass nur ein bestimmtes Repository auf Ihren Satis composer-Server gelangt.

  • Option 2: Integrieren Sie Webhook in Ihr Git-Tool

Sie können diesen Webhook ganz einfach mit Ihrem bevorzugten Git-Tool wie Github, Gitlab, Bitbucket usw. konfigurieren. Hier sind ein paar Beispiele.

Webook auf Github

  • Schritt 1. Gehen Sie zu Ihren Repositories > Einstellungen > Webhooks
  • Schritt 2. Klicken Sie auf "Webhook hinzufügen".

Schritt 3. Fügen Sie Ihre webhook.php-URL, Ihren geheimen Schlüssel usw. hinzu, und speichern Sie das Formular.

Webhaken bei Gitlab

  • Schritt 1.Gehen Sie zu Ihren Gitlab Repositories > Einstellungen > Integration
  • Schritt 2. Setzen Sie Ihre webhook.php URL, den geheimen Schlüssel und senden Sie webhook.

Schritt 3. Bearbeiten Sie Ihren Webhook, Sie können eine Testfahrt machen, indem Sie "Test" einreichen, und Sie können die Anfrage und die Antwort auschecken.

Schritt 6. Cron zum Crawlen automatischer privater TYPO3-Pakete einrichten

Wir schlagen vor, CRON so einzustellen, dass Ihre privaten TYPO3-Pakete regelmäßig von jedem Ihrer einzelnen Git-Repositorys gecrawlt werden.

Schauen wir uns ein Beispiel an,

Täglich um 12 Uhr laufen die cron

* * * * * usr/bin/php7 /var/www/your/path/satis/bin build /var/www/your/path/satis.json /var/www/your/path/

Schritt 7. Sichern Sie Ihre privaten TYPO3-Pakete auf dem Composer-Server

Ich weiß, Ihre erste Frage könnte sein, wie Sie Ihre Pakete auf dem Composer-Server sichern können?

Leider gibt es viele Möglichkeiten, Ihren Kunden oder Ihr Team wie folgt zu schützen und ihm Zugriff/Authentifizierung zu gewähren.

Tipps

Stellen Sie sicher, dass Sie robots.txt einrichten, um das SEO-Crawling zu deaktivieren.

Hier finden Sie Listen von Sicherheitsoptionen, die wie folgt verfügbar sind.

Option 1. SSH (erfordert die SSH2-PECL-Erweiterung)

{
    "repositories": [{
        "type": "composer",
        "url": "ssh2.sftp://yourdomain.com",
        "options": {
            "ssh2": {
            "username": "composer",
            "pubkey_file": "/home/composer/.ssh/id_rsa.pub",
            "privkey_file": "/home/composer/.ssh/id_rsa"
            }
        }
    }]
}

Option 2. SSL/TLS (HTTPS) unter Verwendung eines Client-Zertifikats

{
    "repositories": [{
        "type": "composer",
        "url": "https://yourdomain.com",
            "options": {
            "ssl": {
            "local_cert": "/home/composer/.ssl/composer.pem"
            }
        }
    }]
}

Option 3. Custom HTTP Header field for token authentication

{
    "repositories": [{
        "type": "composer",
        "url": "https://yourdomain.com",
        "options": {
            "http": {
                "header": [
                "API-TOKEN: YOUR-API-TOKEN"
                ]
            }
        }
    }]
}

Nun stellen Sie sich vor, Sie haben einen Kunden, der Ihr tolles TYPO3-Paket bei Ihnen kauft. Er möchte eine composer-basierte TYPO3-Erweiterung installieren. Da der Komponist http-basierte Authentifizierung unterstützt, ist das praktisch die Lösung. Hier ist die Schritt-für-Schritt-Anleitung zur Einrichtung von sicheren und kennwortgeschützten privaten TYPO3-Paketen für einen Komponisten.

Schritt 1. Einrichtung .htaccess

# Let’s allow webhook.php to access for your Git-tools
<FilesMatch "webhook.php">
    SetEnvIf Request_URI "webhook.php$" allow
    Order allow,deny
    Allow from env=allow
    Satisfy any
</FilesMatch>

# Let’s set authentication      
AuthUserFile /path/to/.htpasswd
AuthType Basic
AuthName "My Composer Restriction"
Require valid-user

Schritt 2.erstellen .htpasswd

Fügen Sie Ihren Benutzernamen und Ihr Passwort hinzu, Sie können Cool-Tools wie

https://www.web2generators.com/apache-tools/htpasswd-generator

Das war's. Versuchen wir nun, mit Ihrer TYPO3 Composer-basierten Installation auf Ihren Server zuzugreifen.

Testlauf-Authentifizierung bei Ihrem TYPO3-Composer

Schritt 1. Konfigurieren Sie Ihre composer.json

Stellen Sie sicher, dass Sie composer.json mit Ihrem composer-server anstelle von packagist.org konfigurieren, siehe Checkout über dem Thema Testlauf.

Schritt 2. Fragen Sie nach der Authentifizierung

Ein Komponist wird also auf Ihren Server schauen, um die neuesten privaten TYPO3-Pakete herunterzuladen, und er sollte nach einer Authentifizierung fragen.

Authentifizierungszugang einzelner Pakete

Hmm, Sie suchen also die Authentifizierung zu jedem TYPO3-Paket einzeln, keine Sorge, Sie können auch mit Ihrem .Htaccess und Server einfach endlose Möglichkeiten konfigurieren.

.htaccess

# Let’s allow webhook.php to access for your Git-tools
<FilesMatch "webhook.php">
    SetEnvIf Request_URI "webhook.php$" allow
    Order allow,deny
    Allow from env=allow
    Satisfy any
<FilesMatch>

# Configure your package1
<FilesMatch "^(your-package1-prefix.*)\.(zip)$">
    AuthName "Access of My Composer"
    AuthUserFile /access/.htpasswd_your_package1
    AuthType basic
    Require valid-user
<FilesMatch>

# Configure your package1
<FilesMatch "^(your-package2-prefix.*)\.(zip)$">
    AuthName "Access of composer.t3planet.com"
    AuthUserFile /access/.htpasswd_your_package2
    AuthType basic
    Require valid-user
<FilesMatch>

Anmerkungen: Um einen Hinweis darauf zu erhalten, was genau in FileMatch einzustellen ist, gehen Sie einfach zu Ihrem /dist/vendor/package to the end zip file. Sie können einen Präfix-Match aus dieser Zip-Datei setzen.

Einpacken!

  • Für Ihren Komponisten: Wenn Sie Zugang zu privaten Paketen oder eine bessere Leistung im Vergleich zu packagist.org wünschen, dann wählen Sie einfach die großartige Satis-Lösung.
  • Sie können jetzt erkennen, dass die Erstellung Ihrer privaten TYPO3-Pakete ganz einfach ist. Probieren Sie einfach alle Schritte 1 bis 7 aus, um den Satis composer-server zu installieren und zu konfigurieren.
  • Alle Schritte sind gut erprobt, so dass wir sicher sind, dass Sie keine großen Schwierigkeiten bekommen werden.

Wir hoffen, dass Ihnen dieser einfache Leitfaden für die Einrichtung von Satis gefällt. Kennen Sie noch andere Möglichkeiten, private TYPO3-Pakete für den Composer zu erstellen? Schreiben Sie bitte in das Kommentarfeld, falls Sie irgendwelche Probleme oder Fragen haben.

Bitte stellen Sie diesen Artikel in Ihren TYPO3-Netzwerken zur Verfügung.

Haben Sie eine glückliche Zeit mit einem großen Komponisten :)

Post a Comment

×
Captcha Code Kann das Bild nicht gelesen werden? Klicken Sie hier, um zu aktualisieren
  • user
    Charles 2023-07-14 um 4:02 pm
    Kudos to you for this fantastic blog post!
  • user
    Paul N. Greene 2023-07-14 um 4:02 pm
    This is exactly what I was looking for!