Suivant: , Précédent: , Monter: Services   [Table des matières][Index]


8.8.16 Services web

Le module (gnu services web) fournit le serveur Apache HTTP, le serveur web nginx et aussi un démon fastcgi.

Serveur Apache HTTP

Variable Scheme : httpd-service-type

Type de service pour le serveur Apache HTTP (httpd). La valeur de ce type de service est un enregistrement httpd-configuration.

Un exemple de configuration simple est donné ci-dessous.

(service httpd-service-type
         (httpd-configuration
           (config
             (httpd-config-file
               (server-name "www.example.com")
               (document-root "/srv/http/www.example.com")))))

D’autres services peuvent aussi étendre httpd-service-type pour être ajouté à la configuration.

(simple-service 'www.example.com-server httpd-service-type
                (list
                  (httpd-virtualhost
                    "*:80"
                    (list (string-join '("ServerName www.example.com"
                                          "DocumentRoot /srv/http/www.example.com")
                                       "\n")))))

Les détails des types d’enregistrement httpd-configuration, httpd-module, httpd-config-file et httpd-virtualhost sont donnés plus bas.

Type de données : httpd-configuration

Ce type de données représente la configuration du service httpd.

package (par défaut : httpd)

Le paquet httpd à utiliser.

pid-file (par défaut : "/var/run/httpd")

Le fichier de pid utilisé par le service shepherd.

config (par défaut : (httpd-config-file))

Le fichier de configuration à utiliser avec le service httpd. La valeur par défaut est un enregistrement httpd-config-file mais cela peut aussi être un G-expression qui génère un fichier, par exemple un plain-file. Un fichier en dehors du dépôt peut aussi être spécifié avec une chaîne de caractères.

Type de données : httpd-module

Ce type de données représente un module pour le service httpd.

name

Le nom du module.

file

Le fichier pour le module. Cela peut être relatif au paquet httpd utilisé, l’emplacement absolu d’un fichier ou une G-expression pour un fichier dans le dépôt, par exemple (file-append mod-wsgi "/modules/mod_wsgi.so").

Variable Scheme : %default-httpd-modules

Une liste par défaut des objets httpd-module.

Type de données : httpd-config-file

Ce type de données représente un fichier de configuration pour le service httpd.

modules (par défaut : %default-httpd-modules)

Les modules à charger. Les modules supplémentaires peuvent être ajoutés ici ou chargés par des configuration supplémentaires.

Par exemple, pour gérer les requêtes pour des fichiers PHP, vous pouvez utiliser le module mod_proxy_fcgi d’Apache avec php-fpm-service-type :

(service httpd-service-type
         (httpd-configuration
          (config
           (httpd-config-file
            (modules (cons*
                      (httpd-module
                       (name "proxy_module")
                       (file "modules/mod_proxy.so"))
                      (httpd-module
                       (name "proxy_fcgi_module")
                       (file "modules/mod_proxy_fcgi.so"))
                      %default-httpd-modules))
            (extra-config (list "\
<FilesMatch \\.php$>
    SetHandler \"proxy:unix:/var/run/php-fpm.sock|fcgi://localhost/\"
</FilesMatch>"))))))
(service php-fpm-service-type
         (php-fpm-configuration
          (socket "/var/run/php-fpm.sock")
          (socket-group "httpd")))
server-root (par défaut : httpd)

Le ServerRoot dans le fichier de configuration, par défaut le paquet httpd. Les directives comme Include et LoadModule sont prises relativement à la racine du serveur.

server-name (par défaut : #f)

Le ServerName dans le fichier de configuration, utilisé pour spécifier le schéma de requête, le nom d’hôte et le port que le serveur utilise pour s’identifier.

This doesn’t need to be set in the server config, and can be specified in virtual hosts. The default is #f to not specify a ServerName.

document-root (par défaut : "/srv/http")

Le DocumentRoot depuis lequel les fichiers seront servis.

listen (par défaut : '("80"))

La liste des valeurs pour les directives Listen dans le fichier de configuration. La valeur devrait être une liste de chaînes, où chacune spécifie le port sur lequel écouter et éventuellement une adresse IP et un protocole à utiliser.

pid-file (par défaut : "/var/run/httpd")

Le PidFile à utiliser. Cela devrait correspondre à pid-file indiqué dans httpd-configuration pour que le service Shepherd soit correctement configuré.

error-log (par défaut : "/var/log/httpd/error_log")

Le ErrorLog où le serveur écrit les journaux d’erreurs.

user (par défaut : "httpd")

Le User en tant que lequel le serveur répondra aux requêtes.

group (par défaut : "httpd")

Le Group que le serveur utilisera pour répondre aux requêtes.

extra-config (par défaut : (list "TypesConfig etc/httpd/mime.types"))

Une liste plate de chaînes et de G-expressions qui seront ajoutées à la fin du fichier de configuration.

N’importe quelle valeur avec laquelle le service est étendu sera ajouté à cette liste.

Type de données : httpd-virtualhost

Ce type de données représente la configuration d’un hôte virtuel pour le service httpd.

Ils devraient être ajoutés à extra-config dans httpd-service.

(simple-service 'www.example.com-server httpd-service-type
                (list
                  (httpd-virtualhost
                    "*:80"
                    (list (string-join '("ServerName www.example.com"
                                          "DocumentRoot /srv/http/www.example.com")
                                       "\n")))))
addresses-and-ports

L’adresse et le port pour la directive VirtualHost.

contents

Le contenu de la directive VirtualHost, cela devrait être une liste de chaîne et de G-expressions.

NGINX

Variable Scheme : nginx-service-type

Type de service pour le serveur web NGinx. La valeur de ce service est un enregistrement <nginx-configuration>.

Un exemple de configuration simple est donné ci-dessous.

(service nginx-service-type
         (nginx-configuration
           (server-blocks
             (list (nginx-server-configuration
                     (server-name '("www.example.com"))
                     (root "/srv/http/www.example.com"))))))

En plus d’ajouter des blocs de serveurs dans la configuration du service directement, ce service peut être étendu par d’autres services pour ajouter des blocs de serveurs, comme dans cet exemple :

(simple-service 'my-extra-server nginx-service-type
                (list (nginx-server-configuration
                        (root "/srv/http/extra-website")
                        (try-files (list "$uri" "$uri/index.html")))))

Au démarrage, nginx n’a pas encore lu son fichier de configuration, donc il utilise les fichiers par défaut pour les messages d’erreur. S’il échoue à charger sa configuration, c’est là où les messages seront enregistrés. Après la lecture du fichier de configuration, le fichier de journal d’erreur par défaut change en fonction de celle-ci. Dans notre cas, les messages d’erreur au démarrage se trouvent dans /var/run/nginx/logs/error.log et après la configuration dans /var/log/nginx/error.log. Ce second emplacement peut être modifié avec l’option de configuration log-directory.

Type de données : nginx-configuration

Ce type de données représente la configuration de NGinx. Certaines configurations peuvent se faire ici et d’autres fournissent des types d’enregistrement ou éventuellement, on peut fournir un fichier de configuration.

nginx (par défaut : nginx)

Le paquet nginx à utiliser.

log-directory (par défaut : "/var/log/nginx")

Le répertoire dans lequel NGinx écrira ses fichiers journaux.

run-directory (par défaut : "/var/run/nginx")

Le répertoire dans lequel NGinx créera un fichier de pid et écrira des fichiers temporaires.

server-blocks (par défaut : '())

Une liste de blocs serveur à créer dans le fichier de configuration généré, dont les éléments sont de type <nginx-server-configuration>.

L’exemple suivant paramètre NGinx pour servir www.example.com depuis le répertoire /srv/http/www.example.com sans utiliser HTTPS.

(service nginx-service-type
         (nginx-configuration
           (server-blocks
             (list (nginx-server-configuration
                     (server-name '("www.example.com"))
                     (root "/srv/http/www.example.com"))))))
upstream-blocks (par défaut : '())

Une liste de blocs amont à créer dans le fichier de configuration généré, dont les éléments sont de type <nginx-upstream-configuration>.

Configurer les serveurs amont à travers les upstream-blocks peut être utile en combinaison avec locations dans les enregistrements <nginx-server-configuration>. L’exemple suivant crée une configuration de serveur avec une configuration « location » qui sera mandataire pour une configuration amont, qui gérera les requêtes avec deux serveurs.

(service
  nginx-service-type
  (nginx-configuration
    (server-blocks
      (list (nginx-server-configuration
              (server-name '("www.example.com"))
              (root "/srv/http/www.example.com")
              (locations
                (list
                  (nginx-location-configuration
                  (uri "/path1")
                  (body '("proxy_pass http://server-proxy;"))))))))
    (upstream-blocks
      (list (nginx-upstream-configuration
              (name "server-proxy")
              (servers (list "server1.example.com"
                             "server2.example.com")))))))
file (par défaut : #f)

Si un fichier de configuration file est fourni, il sera utilisé au lieu de générer un fichier de configuration à partir des log-directory, run-directory, server-blocks et upstream-blocks fournis. Pour un bon fonctionnement, ces arguments devraient correspondre à ce qui se trouve dans file pour s’assurer que les répertoires sont créé lorsque le service est activé.

Cela peut être utile si vous avez déjà un fichier de configuration existant ou s’il n’est pas possible de faire ce dont vous avez besoin avec les autres parties de l’enregistrement nginx-configuration.

server-names-hash-bucket-size (par défaut : #f)

Taille du seau pour les tables de hashage des noms de serveurs, par dauft #f pour utilise la taille des lignes de cache du processeur.

server-names-hash-bucket-max-size (par défaut : #f)

Taille maximum des seaux pour les tables de hashage des serveurs de noms.

modules (par défaut : '())

List of nginx dynamic modules to load. This should be a list of file names of loadable modules, as in this example:

(modules
 (list
  (file-append nginx-accept-language-module "\
/etc/nginx/modules/ngx_http_accept_language_module.so")))
global-directives (default: '((events . ())))

Association list of global directives for the top level of the nginx configuration. Values may themselves be association lists.

(global-directives
 `((worker_processes . 16)
   (pcre_jit . on)
   (events . ((worker_connections . 1024)))))
extra-content (par défaut : "")

Contenu supplémentaire du bloc http. Cela devrait être une chaîne ou un G-expression.

Type de données : nginx-server-configuration

Type de données représentant la configuration d’un bloc serveur de nginx. Ce type a les paramètres suivants :

listen (par défaut : '("80" "443 ssl"))

Chaque directive listen indique l’adresse et le port pour le protocole IP ou le chemin d’un socket UNIX-domain sur lequel le serveur acceptera les connexions. On peut spécifier l’adresse et le port, ou juste l’adresse ou juste le port. Une adresse peut aussi être un nom d’hôte, par exemple :

'("127.0.0.1:8000" "127.0.0.1" "8000" "*:8000" "localhost:8000")
server-name (par défaut : (list 'default))

Une liste de noms de serveurs que ce serveur représente. 'default représente le serveur par défaut pour les connexions qui ne correspondent à aucun autre serveur.

root (par défaut : "/srv/http")

Racine du site web que sert nginx.

locations (par défaut : '())

Une liste d’enregistrements nginx-location-configuration ou nginx-named-location-configuration à utiliser dans ce bloc serveur.

index (par défaut : (list "index.html"))

Fichiers d’index à chercher lorsque les clients demandent un répertoire. S’il ne peut pas être trouvé, Nginx enverra la liste des fichiers dans le répertoire.

try-files (par défaut : '())

Une liste de fichiers dont l’existence doit être vérifiée dans l’ordre spécifié. nginx utilisera le premier fichier trouvé pour satisfaire la requête.

ssl-certificate (par défaut : #f)

Où trouver les certificats pour les connexions sécurisées. Indiquez #f si vous n’avez pas de certificats et que vous ne voulez pas utiliser HTTPS.

ssl-certificate-key (par défaut : #f)

Où trouver la clef privée pour les connexions sécurisées. Indiquez #f si vous n’avez pas de clef et que vous ne voulez pas utiliser HTTPS.

server-tokens? (par défaut : #f)

Indique si le serveur devrait ajouter sa configuration dans les réponses.

raw-content (par défaut : '())

Une liste de lignes brutes à ajouter dans le bloc serveur.

Type de données : nginx-upstream-configuration

Type de données représentant la configuration d’un bloc upstream nginx. Ce type a les paramètres suivants :

name

Nome de ces groupe de serveurs.

serveurs

Spécifie les adresses des serveurs dans le groupe. L’adresse peut être spécifié avec une adresse IP (p. ex. ‘127.0.0.1’), un nom de domaine (p. ex. ‘backend1.example.com’) ou un chemin vers un socket UNIX avec le préfixe ‘unix:’. Pour les adresse utilisant une adresse IP ou un nom de domaine, le port par défaut est 80 et un port différent peut être spécifié explicitement.

Type de données : nginx-location-configuration

Type de données représentant la configuration d’un bloc location nginx. Ce type a les paramètres suivants :

uri

URI qui correspond à ce bloc.

body

Corps du block location, spécifié comme une liste de chaînes de caractères. Cela peut contenir de nombreuses directives de configuration. Par exemple, pour passer des requêtes à un groupe de serveurs amont définis dans un bloc nginx-upstream-configuration, la directive suivante peut être spécifiée dans le corps : ‘(list "proxy_pass http://upstream-name;")’.

Type de données : nginx-named-location-configuration

Type de données représentant la configuration d’un bloc location nginx nommé. Les blocs location nommés sont utilisé les redirections de requêtes et pas pour le traitement des requêtes normales. Ce type a les paramètres suivants :

name

Nom pour identifier ce bloc location.

body

Voir nginx-location-configuration body, comme le corps d’un bloc location nommé peut être utilisé de la même manière que nginx-location-configuration body. Une restriction est que le corps d’un bloc location nommé ne peut pas contenir de bloc location.

Cache Varnish

Varnish est un serveur de cache rapide qui se trouve entre les applications web et les utilisateurs. Il sert de serveur mandataire pour les requêtes des clients et met les URL accédées en cache pour que plusieurs requêtes à la même ressource ne crée qu’une requête au moteur.

Variable Scheme : varnish-service-type

Type de service pour le démon Varnish.

Type de données : varnish-configuration

Type de données représentant la configuration du service varnish. Ce type a les paramètres suivants :

package (par défaut : varnish)

Le paquet Varnish à utiliser.

name (par défaut : "default")

Un nom pour cet instance de Varnish. Varnish va créer un répertoire dans /var/varnish/ avec ce nom et gardera des fichiers temporaires à cet endroit. Si le nom commence par une barre oblique, il est interprété comme un nom de répertoire absolu.

Passez l’argument -n aux autres programmes Varnish pour vous connecter à l’instance nommée, p. ex. varnishncsa -n default.

backend (par défaut : "localhost:8080")

Le moteur à utiliser. Cette option n’a pas d’effet si vcl est vrai.

vcl (par défaut : #f)

Le programme VCL (Varnish Configuration Language) à lancer. Si la valeur est #f, Varnsh servira de mandataire pour backend avec la configuration par défaut. Sinon, ce doit être un objet simili-fichier avec une syntaxe VCL valide.

For example, to mirror www.gnu.org with VCL you can do something along these lines:

(define %gnu-mirror
  (plain-file "gnu.vcl"
              "vcl 4.1;
backend gnu { .host = \"www.gnu.org\"; }"))

(operating-system
  ;; …
  (services (cons (service varnish-service-type
                           (varnish-configuration
                            (listen '(":80"))
                            (vcl %gnu-mirror)))
                  %base-services)))

On peut inspecter la configuration d’une instance Varnish actuellement lancée en utilisant le programme varnishadm.

Consultez le guide utilisateur de varnish et le livre varnish pour une documentation complète sur Varnish et son langage de configuration.

listen (par défaut : '("localhost:80"))

Liste des adresses sur lesquelles écoute Varnish.

storage (par défaut : '("malloc,128m"))

Liste de moteurs de stockage qui seront disponibles en VCL.

parameters (par défaut : '())

Liste des paramètres à l’exécution de la forme '(("parameter" . "value")).

extra-options (par défaut : '())

Arguments supplémentaires à passer au processus varnishd.

Patchwork

Patchwork is a patch tracking system. It can collect patches sent to a mailing list, and display them in a web interface.

Scheme Variable : patchwork-service-type

Service type for Patchwork.

The following example is an example of a minimal service for Patchwork, for the patchwork.example.com domain.

(service patchwork-service-type
         (patchwork-configuration
          (domain "patchwork.example.com")
          (settings-module
           (patchwork-settings-module
            (allowed-hosts (list domain))
            (default-from-email "patchwork@patchwork.example.com")))
          (getmail-retriever-config
           (getmail-retriever-configuration
            (type "SimpleIMAPSSLRetriever")
            (server "imap.example.com")
            (port 993)
            (username "patchwork")
            (password-command
             (list (file-append coreutils "/bin/cat")
                   "/etc/getmail-patchwork-imap-password"))
            (extra-parameters
            '((mailboxes . ("Patches"))))))))

There are three records for configuring the Patchwork service. The <patchwork-configuration> relates to the configuration for Patchwork within the HTTPD service.

The settings-module field within the <patchwork-configuration> record can be populated with the <patchwork-settings-module> record, which describes a settings module that is generated within the Guix store.

For the database-configuration field within the <patchwork-settings-module>, the <patchwork-database-configuration> must be used.

Data Type : patchwork-configuration

Data type representing the Patchwork service configuration. This type has the following parameters:

patchwork (default: patchwork)

The Patchwork package to use.

domain

The domain to use for Patchwork, this is used in the HTTPD service virtual host.

settings-module

The settings module to use for Patchwork. As a Django application, Patchwork is configured with a Python module containing the settings. This can either be an instance of the <patchwork-settings-module> record, any other record that represents the settings in the store, or a directory outside of the store.

static-path (default: "/static/")

The path under which the HTTPD service should serve the static files.

getmail-retriever-config

The getmail-retriever-configuration record value to use with Patchwork. Getmail will be configured with this value, the messages will be delivered to Patchwork.

Data Type : patchwork-settings-module

Data type representing a settings module for Patchwork. Some of these settings relate directly to Patchwork, but others relate to Django, the web framework used by Patchwork, or the Django Rest Framework library. This type has the following parameters:

database-configuration (default: (patchwork-database-configuration))

The database connection settings used for Patchwork. See the <patchwork-database-configuration> record type for more information.

secret-key-file (default: "/etc/patchwork/django-secret-key")

Patchwork, as a Django web application uses a secret key for cryptographically signing values. This file should contain a unique unpredictable value.

If this file does not exist, it will be created and populated with a random value by the patchwork-setup shepherd service.

This setting relates to Django.

allowed-hosts

A list of valid hosts for this Patchwork service. This should at least include the domain specified in the <patchwork-configuration> record.

This is a Django setting.

default-from-email

The email address from which Patchwork should send email by default.

This is a Patchwork setting.

static-url (default: #f)

The URL to use when serving static assets. It can be part of a URL, or a full URL, but must end in a /.

If the default value is used, the static-path value from the <patchwork-configuration> record will be used.

This is a Django setting.

admins (default: '())

Email addresses to send the details of errors that occur. Each value should be a list containing two elements, the name and then the email address.

This is a Django setting.

debug? (par défaut : #f)

Whether to run Patchwork in debug mode. If set to #t, detailed error messages will be shown.

This is a Django setting.

enable-rest-api? (default: #t)

Whether to enable the Patchwork REST API.

This is a Patchwork setting.

enable-xmlrpc? (default: #t)

Whether to enable the XML RPC API.

This is a Patchwork setting.

force-https-links? (default: #t)

Whether to use HTTPS links on Patchwork pages.

This is a Patchwork setting.

extra-settings (par défaut : "")

Extra code to place at the end of the Patchwork settings module.

Data Type : patchwork-database-configuration

Data type representing the database configuration for Patchwork.

engine (default: "django.db.backends.postgresql_psycopg2")

The database engine to use.

name (default: "patchwork")

The name of the database to use.

user (par défaut : "httpd")

The user to connect to the database as.

password (default: "")

The password to use when connecting to the database.

host (default: "")

The host to make the database connection to.

port (default: "")

The port on which to connect to the database.

Mumi

Mumi is a Web interface to the Debbugs bug tracker, by default for the GNU instance. Mumi is a Web server, but it also fetches and indexes mail retrieved from Debbugs.

Scheme Variable : mumi-service-type

This is the service type for Mumi.

Data Type : mumi-configuration

Data type representing the Mumi service configuration. This type has the following fields:

mumi (default: mumi)

The Mumi package to use.

mailer? (default: #true)

Whether to enable or disable the mailer component.

mumi-configuration-sender

The email address used as the sender for comments.

mumi-configuration-smtp

A URI to configure the SMTP settings for Mailutils. This could be something like sendmail:///path/to/bin/msmtp or any other URI supported by Mailutils. Voir SMTP Mailboxes dans GNU Mailutils.

FastCGI

FastCGI est une interface entre le frontal et le moteur d’un service web. C’est un dispositif quelque peu désuet ; les nouveaux services devraient généralement juste parler HTTP entre le frontal et le moteur. Cependant il y a un certain nombre de services de moteurs comme PHP ou l’accès aux dépôts Git optimisé en HTTP qui utilisent FastCGI, donc nous le supportons dans Guix.

Pour utiliser FastCGI, vous configurez le serveur web frontal (p. ex. nginx) pour envoyer un sous-ensemble de ses requêtes au moteur fastcgi, qui écoute sur un socket UNIX ou TCP local. Il y a un programme fcgiwrap intermédiaire qui se trouve entre le processus du moteur et le serveur web. Le frontal indique quel moteur lancer, en passant cette information au processus fcgiwrap.

Variable Scheme : fcgiwrap-service-type

Un type de service pour le mandataire FastCGI fcgiwrap.

Type de données : fcgiwrap-configuration

Type de données représentant la configuration du service fcgiwrap. Ce type a les paramètres suivants :

package (par défaut : fcgiwrap)

Le paquet fcgiwrap à utiliser.

socket (par défaut : tcp:127.0.0.1:9000)

Le socket sur lequel le processus fcgiwrap écoute, en tant que chaîne de caractères. Les valeurs valides de socket sont unix:/path/to/unix/socket, tcp:dot.ted.qu.ad:port et tcp6:[ipv6_addr]:port.

user (par défaut : fcgiwrap)
group (par défaut : fcgiwrap)

Les noms de l’utilisateur et du groupe, en tant que chaînes de caractères, sous lesquels lancer le processus fcgiwrap. Le service fastcgi s’assurera que si l’utilisateur demande les noms d’utilisateurs et de groupes fcgiwrap l’utilisateur et le groupe correspondant seront présents sur le système.

It is possible to configure a FastCGI-backed web service to pass HTTP authentication information from the front-end to the back-end, and to allow fcgiwrap to run the back-end process as a corresponding local user. To enable this capability on the back-end, run fcgiwrap as the root user and group. Note that this capability also has to be configured on the front-end as well.

PHP-FPM (FastCGI Process Manager) est une implémentation FastCGI de PHP alternative avec quelques fonctionnalités supplémentaires utiles pour les sites de toutes tailles.

Ces fonctionnalités comprennent :

… et bien plus.

Variable Scheme : php-fpm-service-type

Un type de service pour php-fpm.

Type de données : php-fpm-configuration

Type de données pour la configuration du service php-fpm.

php (par défaut : php)

Le paquet php à utiliser.

socket (par défaut : (string-append "/var/run/php" (version-major (package-version php)) "-fpm.sock"))

L’adresse sur laquelle accepter les requêtes FastCGI. Les syntaxes valides sont :

"ip.add.re.ss:port"

Écoute sur un socket TCP sur l’adresse spécifiée sur un port spécifié.

"port"

Écoute sur un socket TCP sur toutes les adresse sur un port spécifique.

"/path/to/unix/socket"

Écoute sur un socket unix.

user (par défaut : php-fpm)

Utilisateur à qui appartiendra le processus de travail de php.

group (par défaut : php-fpm)

Groupe du processus de travail.

socket-user (par défaut : php-fpm)

Utilisateur qui peut parler au socket php-fpm.

socket-group (default: nginx)

Groupe qui peut parler au socket php-fpm.

pid-file (par défaut : (string-append "/var/run/php" (version-major (package-version php)) "-fpm.pid"))

Le pid de php-fpm est écrit dans ce fichier une fois que le service a démarré.

log-file (par défaut : (string-append "/var/log/php" (version-major (package-version php)) "-fpm.log"))

Fichier de journal pour le processus maître de php-fpm.

process-manager (par défaut : (php-fpm-dynamic-process-manager-configuration))

Detailed settings for the php-fpm process manager. Must be one of:

<php-fpm-dynamic-process-manager-configuration>
<php-fpm-static-process-manager-configuration> ou
<php-fpm-on-demand-process-manager-configuration>
display-errors (par défaut : #f)

Détermine si les erreurs et les avertissements php doivent être envoyés aux clients et affichés dans leur navigateur. Cela est utile pour un développement php local, mais un risque pour la sécurité pour les sites publics, comme les messages d’erreur peuvent révéler des mots de passes et des données personnelles.

timezone (par défaut : #f)

Spécifie le paramètre php_admin_value[date.timezone].

workers-logfile (par défaut : (string-append "/var/log/php" (version-major (package-version php)) "-fpm.www.log"))

Ce fichier enregistrera la sortie stderr des processus de travail de php. On peut indiquer #f pour désactiver la journalisation.

file (par défaut : #f)

Une version alternative de la configuration complète. Vous pouvez utiliser la fonction mixed-text-file ou un chemin de fichier absolu.

Type de données : php-fpm-dynamic-process-manager-configuration

Type de données pour le gestionnaire de processus dynamic de php-fpm. Avec le gestionnaire de processus dynamic, des processus de travail de secours sont gardés en fonction des limites configurées.

max-children (par défaut : 5)

Nombre maximum de processus de travail.

start-servers (par défaut : 2)

Nombre de processus de travail au démarrage.

min-spare-servers (par défaut : 1)

Nombre de processus de travail de secours minimum qui doivent rester à disposition.

max-spare-servers (par défaut : 3)

Nombre maximum de processus de travail de secours qui peuvent rester à disposition.

Type de données : php-fpm-static-process-manager-configuration

Type de données pour le gestionnaire de processus static de php-fpm. Avec le gestionnaire de processus static, un nombre constant de processus de travail est créé.

max-children (par défaut : 5)

Nombre maximum de processus de travail.

Type de données : php-fpm-on-demand-process-manager-configuration

Type de données pour le gestionnaire de processus on-demand de php-fpm. Avec le gestionnaire de processus on-demand, les processus de travail ne sont créés que lorsque les requêtes arrivent.

max-children (par défaut : 5)

Nombre maximum de processus de travail.

process-idle-timeout (par défaut : 10)

La durée en secondes après laquelle un processus sans requête sera tué.

Procédure Scheme : nginx-php-fpm-location [#:nginx-package nginx] [socket (string-append "/var/run/php" (version-major (package-version php)) "-fpm.sock")]

Une fonction d’aide pour ajouter rapidement php à un nginx-server-configuration.

Une configuration simple de services pour php ressemble à ceci :

(services (cons* (service dhcp-client-service-type)
                 (service php-fpm-service-type)
                 (service nginx-service-type
                          (nginx-server-configuration
                           (server-name '("example.com"))
                           (root "/srv/http/")
                           (locations
                            (list (nginx-php-location)))
                           (listen '("80"))
                           (ssl-certificate #f)
                           (ssl-certificate-key #f)))
                 %base-services))

Le générateur d’avatar de chat est un simple service pour démontrer l’utilisation de php-fpm dans Nginx. Il permet de générer des avatars de chats à partir d’une graine, par exemple le hash de l’adresse de courriel d’un utilisateur.

Procédure Scheme : cat-avatar-generator-service [#:cache-dir "/var/cache/cat-avatar-generator"] [#:package cat-avatar-generator] [#:configuration (nginx-server-configuration)]

Renvoie un nginx-server-configuration qui hérite de configuration. Il étend la configuration nginx pour ajouter un bloc de serveur qui sert package, une version de cat-avatar-generator. Pendant l’exécution, cat-avatar-generator pourra utiliser cache-dir comme répertoire de cache.

Une configuration simple de cat-avatar-generator ressemble à ceci :

(services (cons* (cat-avatar-generator-service
                  #:configuration
                  (nginx-server-configuration
                    (server-name '("example.com"))))
                 ...
                 %base-services))

Hpcguix-web

The hpcguix-web program is a customizable web interface to browse Guix packages, initially designed for users of high-performance computing (HPC) clusters.

Variable Scheme : hpcguix-web-service-type

Le type de service pour hpcguix-web.

Type de données : hpcguix-web-configuration

Type de données pour la configuration du service hpcguix-web.

specs

Une gexp (voir G-Expressions) spécifiant la configuration du service hpcguix-web. Les éléments principaux disponibles dans cette spec sont :

title-prefix (par défaut : "hpcguix | ")

Le préfixe du titre des pages.

guix-command (par défaut : "guix")

La commande guix

package-filter-proc (par défaut : (const #t))

Une procédure qui spécifie comment filtrer les paquets qui seront affichés.

package-page-extension-proc (par défaut : (const '()))

Paquet d’extensions pour hpcguix-web.

menu (par défaut : '())

Entrée supplémentaire dans la page menu.

channels (par défaut : %default-channels)

Liste des canaux depuis lesquels la liste des paquets est construite (voir Canaux).

package-list-expiration (par défaut : (* 12 3600))

Le temps d’expiration, en secondes, après lequel la liste des paquets est reconstruite depuis les dernières instance des canaux donnés.

Voir le dépôt hpcguix-web pour un exemple complet

package (par défaut : hpcguix-web)

Le paquet hpcguix-web à utiliser.

Une déclaration de service hpcguix-web typique ressemble à cela :

(service hpcguix-web-service-type
         (hpcguix-web-configuration
          (specs
           #~(define site-config
               (hpcweb-configuration
                (title-prefix "Guix-HPC - ")
                (menu '(("/about" "ABOUT"))))))))

Remarque : Le service hpcguix-web met régulièrement à jour la liste des paquets qu’il publie en récupérant les canaux depuis Git. Pour cela, il doit accéder aux certificats X.509 pour qu’il puisse authentifier les serveurs Git quand il communique en HTTPS, et il suppose que /etc/ssl/certs contient ces certificats.

Ainsi, assurez-vous d’ajouter nss-certs ou un autre paquet de certificats dans le champ packages de votre configuration. Certificats X.509 pour plus d’informations sur les certificats X.509.


Suivant: , Précédent: , Monter: Services   [Table des matières][Index]