7. Configuration avancée du serveur WAPT¶
Le fichier de configuration du serveur WAPT sur les systèmes GNU/Linux et macOS se trouve dans /opt/wapt/conf/waptserver.ini ou dans /opt/wapt/waptserver/waptserver.ini.
Le fichier de configuration du serveur WAPT sous Windows se trouve à l’adresse suivante C:\wapt\conf\waptserver.ini.
Attention
La modification de ces fichiers est réservée aux utilisateurs avancés !!
7.1. Configurations par défaut du fichier waptserver et de nginx¶
7.1.1. Modifier la section [options] du fichier waptserver.ini¶
Plusieurs options peuvent être définies dans la section [options].
[options]
Options (valeur par défaut) |
Description |
Exemple |
|---|---|---|
|
Définit l’endroit où les agents WAPT sont stockés sur le serveur WAPT. |
agents_folder = /var/www/wapt/waptagent |
|
Définit si les connexions websocket doivent être authentifiées. Si |
allow_unauthenticated_connect = True |
|
Permet l’enregistrement initial de l’agent WAPT à l’aide d’un login et d’un mot de passe. |
allow_unauthenticated_registration = True |
|
Débogage uniquement - Permet à l’agent d’envoyer des données d’état non signées. |
allow_unsigned_status_data = True |
|
Définit un chemin d’accès personnalisé à la racine de l’application du serveur WAPT. |
application_root = wapt |
|
Active les journaux d’authentification. |
authentication_logs = False |
|
Crée un waptsetup bourré (conf + certificats personnels sont ajoutés à waptsetup) à partir de chaque configuration créée dans la console WAPT. |
auto_create_waptagent_from_config = True |
|
Définit la durée de vie du certificat d’hôte (en jours). |
durée de vie du certificat du client = 500 |
|
Définit si les :ref:` Windows KB inutilisés doivent être automatiquement supprimés <auto_kb_clean>` du serveur WAPT. |
cleanup_kbs = False |
|
Définit le délai d’attente du client websocket (en secondes). |
clients_read_timeout = 10 |
|
Définit le certificat de signature du certificat de l’hôte. |
clients_signing_certificate = C:\private\org-coder.crt |
|
Définit la périodicité (en jours) de la signature CRL du certificat de l’hôte. |
clients_signing_crl_days = 15 |
|
Définit le chemin d’accès à la CRL de signature du certificat de l’hôte. |
clients_signing_crl = C:\private\org-coder.crt |
|
Définit l’URL de la CRL de signature du certificat de l’hôte. |
clients_signing_crl_url = https://srvwapt.mydomain.lan/crl |
|
Définit le chemin d’accès à la clé de signature du certificat de l’hôte. |
clients_signing_key = C:\private\org-coder.crt |
|
Définit le délai maximum autorisé avant que les demandes de l’agent WAPT n’expirent (en secondes). |
client_tasks_timeout = 5 |
|
Si x64, permet de copier tous les WinPE à partir de |
copy_winpe_x64_in_tftp_folder = True |
|
Définit le délai maximum autorisé avant que les requêtes PostgreSQL n’expirent (en secondes). |
db_connect_timeout = 10 |
|
Définit l’url du serveur PostgreSQL (par défaut WAPT utilise un socket Unix local). |
db_host = https://wapt.mydomain.lan |
|
Définit le nombre maximum de connexions simultanées à la base de données PostgreSQL. |
db_max_connections = 100 |
|
Définit la base de données PostgreSQL à laquelle le serveur WAPT se connecte. |
db_name = wapt |
|
Définit le mot de passe pour l’authentification de l’utilisateur sur la base de données PostgreSQL (par défaut, WAPT utilise un socket UNIX local). |
db_password = WAPT_DB_PASSWORD |
|
Définit le port du serveur PostgreSQL. |
db_port = 5432 |
|
Définit le délai d’expiration de la base de données (en secondes). |
db_stale_timeout = 500 |
|
Définit l’utilisateur PostgreSQL qui se connecte à la base de données. |
db_user = wapt |
|
Définit l’acl par défaut pour un nouvel utilisateur qui ouvre la console WAPT. |
default_ldap_users_acls = admin |
|
Télécharge automatiquement le fichier |
download_wsusscn2 = False |
|
Active WAPT Store Webui (Deprecated). |
enable_store = False |
|
Crypte le paquet de l’hôte avec le certificat du client. |
encrypt_host_packages = True |
|
Ajoute une authentification de base au serveur WAPT. |
htpasswd_path = True |
|
Définit le serveur proxy permettant au serveur WAPT de récupérer sa CRL. |
http_proxy = http://srvproxy.mydomain.lan:3128 |
|
Ajoute une CA supplémentaire connue pour vérifier les certificats. |
known_certificates_folder = /opt/wapt/ssl/ |
|
Définit l’utilisateur UPN Active directory pour le SSO et/ou le mode waptserver-ldap pour le self-service. |
ldap_account_service_login = wapt-ldap@ad.tranquil.it |
|
Définit le mot de passe de l’utilisateur pour le SSO et/ou le mode waptserver-ldap pour le self-service. |
ldap_account_service_password = PASSWORD |
|
Définit le DN de base de l’authentification LDAP. |
ldap_auth_base_dn = dc=mydomain,dc=lan |
|
Définit le serveur d’authentification LDAP. |
ldap_auth_server = srvads.mydomain.lan |
|
Permet la recherche de groupes imbriqués dans Active Directory. |
ldap_nesting_group_support = False |
|
Active la recherche sur les utilisateurs du groupe primaire d’Active Directory. |
ldap_primary_group_ad_support = False |
|
Active la recherche sur les utilisateurs du groupe primaire d’Active Directory.liste des sous-réseaux sans exigence d’authentification. |
list_subnet_skip_login_wads = 192.168.0.0/24,192.168.1.0/24 |
|
Active l’authentification pour utiliser WADS (le format est |
login_on_wads = True |
|
Définit le niveau de journalisation. Les valeurs possibles sont : |
loglevel = debug |
|
Définit le nombre maximum de connexions clients WAPT simultanées. |
max_clients = 2048 |
|
Définit la longueur minimale du mot de passe SuperAdmin. |
min_password_length = 15 |
|
Définit le port HTTP du serveur web Nginx (Windows uniquement). |
nginx_http = 8080 |
|
Définit le port HTTPS du serveur web Nginx (Windows uniquement). |
nginx_https = 44380 |
|
Si l’une des options est définie, elle ne sera pas enregistrée : |
optimized_authentication_logs = False |
|
Définit la périodicité à laquelle le serveur WAPT vérifie l’état de synchronisation des référentiels distants (en minutes). |
remote_repo_update_delay = 5 |
|
Permet la communication par websocket avec les agents WAPT configurés en tant que dépôts distants. |
remote_repo_websockets = False |
|
Définit la chaîne aléatoire pour initialiser le serveur d’application Python Flask. Cette chaîne est générée lors de la première installation du serveur WAPT et est unique pour chaque serveur WAPT. |
secret_key = FKjfzjfkF687fjrkeznfkj7678jknk78687 |
|
Définit le UUID du serveur WAPT (cet identifiant anonyme est utilisé pour les statistiques WAPT). |
server_uuid = 76efezfa6-b309-1fez5-92cd-8ea48fc122dc |
|
Définit la durée maximale d’ouverture de la session (en secondes). |
session_lifetime = 352120 |
|
Définit la différence de temps maximale autorisée pour les websockets (en secondes). |
signature_clockskew = 72000 |
|
Définit la durée de vie du jeton d’authentification (en secondes). |
token_lifetime = 43200 |
|
Définit le chemin d’accès au répertoire des certificats des signataires approuvés. |
trusted_signers_certificates_folder = C:\private\org-coder.crt |
|
Définit le chemin d’accès au répertoire des certificats de l’autorité de certification des utilisateurs approuvés. |
trusted_users_certificates_folder = C:\private\org-coder.crt |
|
Permet à un agent WAPT de s’enregistrer en utilisant son compte kerberos. Si |
use_kerberos = True |
|
use_ssl_client_auth = True |
|
|
Active la fonction WADS et active wapttftpserver. |
wads_enable = True |
|
Définit le dossier sur le serveur WAPT qui stocke les fichiers relatifs aux WADS. |
wads_folder = /var/www/waptwads |
|
Définit le DN LDAP du groupe d’utilisateurs Active Directory autorisé à se connecter à la console WAPT. |
wapt_admin_group_dn = CN=waptadmins,OU=groups,DC=ad,DC=mydomain,DC=lan |
|
Définit le(s) groupe(s) d’utilisateurs Active Directory sAMAccountName autorisé(s) à se connecter à la console WAPT. Il peut s’agir de plusieurs groupes, séparés par des virgules. |
wapt_admin_group = waptadmins, wapttechs |
|
Définit le chemin d’accès au répertoire du référentiel WAPT. |
wapt_folder = /var/www/wapt |
|
Définit le chemin d’accès à la base de données qui stocke l’état des tâches en cours. |
wapt_huey_db = C:\Program Files(x86)\wapt\db\waptservertasks.sqlite |
|
Définit le mot de passe SuperAdmin pour la connexion à la console WAPT. |
wapt_password = 46642dd2b1dfezfezgfezgadf0ezgeezgezf53d |
|
Définit le port du service python du serveur WAPT. |
waptserver_port = 1313 |
|
Définit le nom d’utilisateur SuperAdmin dans la console WAPT. |
wapt_user = wapt_admin |
|
Définit l’emplacement du dossier WAPT WUA. |
waptwua_folder = /var/www/waptwua |
|
Définit la liste des ports UDP de WakeOnLAN auxquels envoyer des paquets magiques. |
wol_port = 9, 123, 4000 |
|
Définit comment écouter le service du serveur WAPT. |
wapt_bind_interface = 127.0.0.1 |
|
Définit l’emplacement du modèle jinja utilisé pour le script ipxe WADS. |
ipxe_script_jinja_path = /opt/wapt/waptserver/templates/ipxe-autoregister.j2 |
7.1.2. Configuration de Nginx¶
La configuration par défaut de Nginx est la suivante :
# uwsgi upstream server
upstream waptserver {
server unix:///run/waptserver/uwsgi.sock;
}
log_format combined_ssl '$remote_addr $ssl_client_s_dn $ssl_client_verify $remote_user [$time_local] '
'"$request" $status $body_bytes_sent '
'"$http_referer" "$http_user_agent"';
server {
listen 80;
listen [::]:80;
listen 443 ssl;
listen [::]:443 ssl;
server_name srvwapt.mydomain.lan;
server_name 192.168.100.12;
access_log "/var/log/nginx/access.log" combined_ssl;
ssl_certificate "/opt/wapt/waptserver/ssl/cert.pem";
ssl_certificate_key "/opt/wapt/waptserver/ssl/key.pem";
ssl_protocols TLSv1.2;
ssl_dhparam "/etc/ssl/certs/dhparam.pem";
ssl_prefer_server_ciphers on;
ssl_ciphers 'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
ssl_stapling on;
ssl_stapling_verify on;
ssl_session_cache none;
ssl_session_tickets off;
# HSTS (ngx_http_headers_module is required) (63072000 seconds)
add_header Strict-Transport-Security "max-age=63072000" always;
ssl_client_certificate "/opt/wapt/conf/ca-srvwapt.mydomain.lan.crt";
ssl_crl "/opt/wapt/conf/ca-check-clients.crl";
ssl_verify_client optional;
gzip_min_length 1000;
gzip_buffers 4 8k;
gzip_http_version 1.0;
gzip_disable "msie6";
gzip_types text/plain text/css application/json;
gzip_vary on;
index index.html;
server_tokens off;
client_max_body_size 12288m;
client_body_timeout 1800;
large_client_header_buffers 4 16k;
proxy_headers_hash_max_size 1024;
proxy_headers_hash_bucket_size 128;
proxy_request_buffering off;
location ^~ /.well-known/acme-challenge/ {
default_type "text/plain";
root /var/www/html;
}
# sub instances
include "/opt/wapt/conf/wapt.d/*.conf";
location /static {
alias "/opt/wapt/waptserver/static";
}
location /ssl {
alias "/var/www/ssl";
}
# not protected URL
location ~ ^/(wapt/waptsetup.*\.exe|wapt/ping|wapt/waptagent/.*|wapt/waptagent\.exe|wapt/waptdeploy\.exe|wapt/conf\.d/.*\.json)$ {
add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
add_header Pragma "no-cache";
root "/var/www";
}
location ~ ^/api/v3/(wads_register_host|set_host_wads_status|baseipxe|get_host_ipxe|get_wads_exe.*|get_wads_config)$ {
proxy_http_version 1.1;
proxy_request_buffering off;
include "/opt/wapt/conf/forward_ssl_auth.conf";
rewrite /(.*) /$1 break;
proxy_pass http://127.0.0.1:8080;
}
# not protected URL
location /wads {
alias "/var/www/wads";
}
location = / {
include "/opt/wapt/conf/forward_ssl_auth.conf";
proxy_pass http://127.0.0.1:8080;
}
# SSL protected URL
location /waptwua {
add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
add_header Pragma "no-cache";
include "/opt/wapt/conf/forward_ssl_auth.conf";
include "/opt/wapt/conf/require_ssl_auth.conf";
alias "/var/www/waptwua";
}
# SSL protected URL
location ~ ^/(wapt/.*|wapt-diff-repos/.*|licences\.json|sync\.json)$ {
add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
add_header Pragma "no-cache";
include "/opt/wapt/conf/forward_ssl_auth.conf";
include "/opt/wapt/conf/require_ssl_auth.conf";
root "/var/www";
}
location /rules.json {
add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
add_header Pragma "no-cache";
include "/opt/wapt/conf/forward_ssl_auth.conf";
root "/var/www";
}
# we don't want to expose our list of computers in case someone scan this folder.
location /wapt-host/Packages {
return 403;
}
location ~ ^/(wapt-host/.*)$ {
log_not_found off;
add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
add_header Pragma "no-cache";
include "/opt/wapt/conf/forward_ssl_auth.conf";
include "/opt/wapt/conf/require_ssl_auth.conf";
root "/var/www";
}
location ~ ^/.*_kerberos$ {
proxy_http_version 1.1;
proxy_request_buffering off;
include "/opt/wapt/conf/forward_ssl_auth.conf";
auth_gss on;
auth_gss_format_full on;
auth_gss_keytab /etc/nginx/http-krb5.keytab;
proxy_pass http://127.0.0.1:8080;
}
# we need socketio for these actions.
# they are enabled only locally on the loopback
location ~ ^/api/v3/(update_hosts_sid_table|hosts_sid)$ {
proxy_http_version 1.1;
proxy_request_buffering off;
include "/opt/wapt/conf/forward_ssl_auth.conf";
rewrite /(.*) /$1 break;
proxy_pass http://127.0.0.1:8080;
allow 127.0.0.1;
deny all;
}
# we need socketio for these actions
location ~ ^/api/v3/(update_hosts_sid_table|trigger_host_action|reset_hosts_sid|host_tasks_status|trigger_cancel_task|hosts_delete|launch_sync_on_remotes_repos|broadcast_sync_on_remotes_repo)$ {
proxy_http_version 1.1;
proxy_request_buffering off;
include "/opt/wapt/conf/forward_ssl_auth.conf";
include "/opt/wapt/conf/require_ssl_auth.conf";
rewrite /(.*) /$1 break;
proxy_pass http://127.0.0.1:8080;
}
location /get_websocket_auth_token {
return 404;
}
# these actions are not protected by SSL client side certificate, as we perhaps don't have one at this stage.
# in case uwsgi is enabled, we wat this to still be handled by eventlet waptserver as these endpoints are not cpu intensive but often called
location ~ ^/(ping)$ {
proxy_http_version 1.1;
proxy_request_buffering off;
include "/opt/wapt/conf/forward_ssl_auth.conf";
rewrite /(.*) /$1 break;
proxy_pass http://127.0.0.1:8080;
}
# these actions are not protected by SSL client side certificate, as we perhaps don't have one at this stage.
location ~ ^/(login|api/v3/login|api/v3/logout|api/v3/get_hash_json_content|api/v3/waptagent_version|add_host|api/v3/add_host|api/v3/get_waptagent_exe/.*/waptagent.exe)$ {
proxy_http_version 1.1;
proxy_request_buffering off;
include "/opt/wapt/conf/forward_ssl_auth.conf";
rewrite /(.*) /$1 break;
include /opt/wapt/conf/uwsgi_params;
uwsgi_pass waptserver;
}
location / {
proxy_http_version 1.1;
proxy_request_buffering off;
include "/opt/wapt/conf/forward_ssl_auth.conf";
include "/opt/wapt/conf/require_ssl_auth.conf";
include /opt/wapt/conf/uwsgi_params;
uwsgi_pass waptserver;
}
location /socket.io {
proxy_http_version 1.1;
proxy_request_buffering off;
include "/opt/wapt/conf/forward_ssl_auth.conf";
include "/opt/wapt/conf/require_ssl_auth.conf";
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
proxy_pass http://127.0.0.1:8080/socket.io;
}
}
7.2. Configuration du serveur WAPT pour les grandes infrastructures¶
Les paramètres par défaut du système d’exploitation, de Nginx et de PostgreSQL sont adaptés à environ 400 agents WAPT. Si vous avez plus de 400 clients, il est nécessaire de modifier quelques paramètres au niveau du système ainsi que la base de données PostgreSQL, le serveur web Nginx et le serveur python WAPT.
Dans le futur, le script postconf.sh pourrait prendre en charge cette configuration en fonction du nombre d’ordinateurs clients attendus.
Avec les paramètres suivants, un serveur WAPT devrait être capable de gérer environ 5 000 clients actifs simultanés. Vous pouvez avoir plus de clients dans la base de données s’ils ne fonctionnent pas tous en même temps. Si vous avez plus de 5000 clients, il est recommandé d’avoir plus d’un serveur WAPT.
La limite du nombre de clients finaux est due au goulot d’étranglement dans le code python et le backend PostgreSQL. Les performances de WAPT s’améliorent avec le temps et, à l’avenir, le serveur WAPT pourrait prendre en charge une large base sur un seul hôte. Cependant, la partie Nginx s’adapte très bien et peut tirer pleinement parti d’une connexion 10Gbps pour les déploiements de paquets à forte charge.
Note
Les paramètres à modifier ci-dessous sont liés entre eux et doivent être modifiés globalement et non individuellement.
7.2.1. Prise en charge du multithreading avec uWSGI¶
Pour activer le multithreading avec uWSGI, vous pouvez ajouter le paramètre suivant dans la section [options] du fichier :/opt/wapt/conf/waptserver.ini :
use_uwsgi = True
Vous devez exécuter /opt/wapt/waptserver/scripts/postconf.sh après cette modification.
7.2.2. Configuration de Nginx¶
Type d’OS |
Emplacement du fichier |
|---|---|
Debian et dérivés |
|
RedHat et dérivés |
|
Windows |
|
Dans le fichier nginx.conf, modifiez le paramètre worker_connections. La valeur devrait être environ 2,5 fois le nombre de clients WAPT (n connexions pour les websockets et n connexions pour les téléchargements de paquets et d’inventaires + une certaine marge).
events {
worker_connections 4096;
}
Ensuite, augmentez le nombre de filedescriptors dans le fichier nginx.conf :
worker_rlimit_nofile 32768;
En fonction du partitionnement de votre serveur WAPT, vous devrez peut-être faire attention au répertoire de téléchargement des fichiers temporaires de Nginx. Nginx agit comme un proxy inverse pour le moteur Python du serveur WAPT et met en cache les paquets téléchargés lors du téléchargement d’un nouveau paquet à partir de la console.
The packages are stored in the /var/lib/nginx/proxy directory.
You have to make sure that the partition hosting this directory is large enough.
You may change this directory location using the following Nginx configuration parameter.
$client_body_temp_path
7.2.3. Configuration du système Linux¶
Augmenter le nombre de filedescriptors. Le fichier unité du système demande une augmentation du nombre autorisé de filedescriptors (LimitNOFILE=32768). Nous devrions avoir la même chose pour Nginx. Il y a quelques limites à modifier.
Tout d’abord, nous modifions au niveau du système le nombre de filedescriptors autorisés pour Nginx et WAPT.
Créez le fichier :/etc/security/limits.d/wapt.conf.
cat > /etc/security/limits.d/wapt.conf <<EOF
wapt hard nofile 32768
wapt soft nofile 32768
www-data hard nofile 32768
www-data soft nofile 32768
EOF
Nginx sert de proxy inverse et établit un grand nombre de connexions. Chaque client WAPT maintient une connexion websocket en permanence afin de répondre aux actions du serveur WAPT.
Le noyau Linux a une protection contre le fait d’avoir trop de connexions TCP ouvertes en même temps et on peut obtenir le message SYN flooding on port dans le journal Nginx. Afin d’éviter ces messages, il est nécessaire de modifier les deux paramètres suivants. Il devrait être environ 1,5 fois le nombre de clients WAPT.
cat > /etc/sysctl.d/wapt.conf <<EOF
net.ipv4.tcp_max_syn_backlog=4096
net.core.somaxconn=4096
EOF
sysctl --system
7.2.4. Configuration de la base de données PostgreSQL¶
Type d’OS |
Emplacement du fichier |
|---|---|
Debian et dérivés |
|
RedHat et dérivés |
|
Windows |
|
Un plus grand nombre de clients nécessite un plus grand nombre de connexions à la base de données PostgreSQL. Dans le fichier postgresql.conf, vous devez augmenter le paramètre suivant à environ 1/4 du nombre d’agents WAPT actifs.
max_connections = 1000
Dans le fichier /opt/wapt/conf/waptserver.ini (pour Windows C:NwaptNconfNwaptserver.ini), db_max_connections doit être égal à PostgreSQL max_connections moins 10 (PostgreSQL a besoin de garder quelques connexions pour ses tâches ménagères). Le paramètre max_clients doit être fixé à environ 1.2 fois le nombre d’agents WAPT :
[options]
...
max_clients = 4096
db_max_connections = 990
7.3. Utilisation des lignes de commande pour la gestion du référentiel¶
7.3.1. wapt-get upload-package¶
La commande wapt-get upload-package <chemin vers le paquet> télécharge un paquet sur le dépôt principal de WAPT.
La commande wapt-get upload-package C:\waptdev\tis-tightvnc.wapt retourne :
Using config file: C:\Users\documentation\AppData\Local\waptconsole\waptconsole.ini
Uploading packages to https://srvwapt.mydomain.lan
Please get login for https://srvwapt.mydomain.lan/api/v3/upload_xxx:admin
Password:
c:\waptdev\tis-tightvnc.wapt[================================] 54316019/54316019 - 00:00:17
OK : 1 Packages uploaded, 0 errors
7.3.2. wapt-get scan-packages¶
Indication
Cette commande s’applique aux dépôts Windows UNIQUEMENT.
La commande wapt-get scan-packages <directory> reconstruit un fichier Packages pour un référentiel de paquets WAPT.
La commande wapt-get scan-packages C:`waptwaptserverrepositorywapt retourne :
Using config file: C:\Program Files (x86)\wapt\wapt-get.ini
Packages filename: C:\wapt\waptserver\repository\wapt
Processed packages:
C:\wapt\waptserver\repository\wapt\tis-firefox.wapt
C:\wapt\waptserver\repository\wapt\tis-tightvnc.wapt
C:\wapt\waptserver\repository\wapt\tis-7zip.wapt
Skipped packages:
7.3.3. wapt-scanpackages¶
Indication
Cette commande s’applique aux dépôts Linux UNIQUEMENT.
La commande wapt-scanpackages <directory> reconstruit un fichier Packages pour un référentiel de paquets WAPT.
La commande wapt-scanpackages /var/www/wapt/ ne renvoie rien.
7.3.4. Re-signature de paquets sur le serveur WAPT à l’aide d’une ligne de commande¶
Utilisez cette méthode si la re-signature à partir de la méthode de la console WAPT n’aboutit pas. Ces commandes sont UNIQUEMENT disponibles pour les serveurs WAPT fonctionnant sous Linux.
Avertissement
Avant d’utiliser cette méthode, assurez-vous que votre serveur WAPT est en sécurité et qu’il n’est pas sous le contrôle d’une entité tierce non autorisée.
Copiez votre
.crtet.pemdans/tmp/sur le serveur WAPT en utilisant Winscp ou un outil équivalent.Il est alors possible de re-signer tous les paquets en une seule fois sur le serveur WAPT avec les commandes suivantes.
wapt-signpackages -d /var/www/wapt-host -c /tmp/wapt_pub_key.crt -k /tmp/wapt_priv_key.pem -s
wapt-signpackages -d /var/www/wapt -c /tmp/wapt_pub_key.crt -k /tmp/wapt_priv_key.pem -s
wapt-scanpackages /var/www/wapt/
Si l’erreur Access violation apparaît, c’est que le paquet WAPT est trop volumineux.
Editez le paquet et vérifiez cette procédure de transfert d’un paquet volumineux.
Danger
Supprimez les fichiers .crt et .pem de /tmp/ sur le serveur WAPT ou le serveur deviendra un bien sensible.
Pour plus d’options disponibles, veuillez consulter la section ligne de commande.