Hide navigation sidebar
Hide table of contents sidebar
Skip to content
Quickstart Official documentation Setuphelpers Changelog FAQ
Back to top
View this page
Toggle table of contents sidebar

# 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`.

Danger

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]

Après avoir modifié le fichier `waptserver.ini`, assurez-vous de redémarrer les waptservices concernés pour appliquer les changements, ou redémarrez le fichier `postconf.sh`.

    systemctl restart wapttasks waptserver

Ouvrir une cmd.exe

    net stop waptservice && net start waptservice

Quelques paramètres disponibles pour la section [options] du `waptserver.ini`

Paramètres LDAP

Options (valeur par défaut) | Description | Exemple
--- | --- | ---
`default_ldap_users_acls` (défaut `view`) | Définit l’acl par défaut pour un nouvel utilisateur qui ouvre la console WAPT. | default_ldap_users_acls = admin
`ldap_account_service_login` (défaut `None`) | 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
`ldap_account_service_password` (défaut `None`) | 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
`ldap_auth_base_dn` (défaut `None`) | Définit le DN de base de l’authentification LDAP. | ldap_auth_base_dn = dc=mydomain,dc=lan
`ldap_auth_server` (défaut `None`) | Définit le serveur d’authentification LDAP. | ldap_auth_server = srvads.mydomain.lan
`ldap_nesting_group_support` (défaut `True`) | Permet la recherche de groupes imbriqués dans Active Directory. | ldap_nesting_group_support = False
`ldap_primary_group_ad_support` (défaut `True`) | Active la recherche sur les utilisateurs du groupe primaire d’Active Directory. | ldap_primary_group_ad_support = False
`wapt_admin_group_dn` (default `None`) | 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
`wapt_admin_group` (défaut `None`) | 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

Paramètres de chemins

Options (valeur par défaut) | Description | Exemple
--- | --- | ---
`agents_folder` (par défaut `watpagent dans le référentiel wapt`) | Définit l’endroit où les agents WAPT sont stockés sur le serveur WAPT. | agents_folder = /var/www/wapt/waptagent
`application_root` (défaut `None`) | Définit un chemin d’accès personnalisé à la racine de l’application du serveur WAPT. | application_root = wapt
`clients_signing_certificate` (défaut `None`) | Définit le certificat de signature du certificat de l’hôte. | clients_signing_certificate = C:\private\org-coder.crt
`clients_signing_crl` (défaut `None`) | 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
`clients_signing_key` (défaut `None`) | 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
`known_certificates_folder` (défaut WAPT `/ssl/` folder) | Ajoute une CA supplémentaire connue pour vérifier les certificats. | known_certificates_folder = /opt/wapt/ssl/
`trusted_signers_certificates_folder` (défaut `None`) | 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
`trusted_users_certificates_folder` (défaut `None`) | 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
`wads_folder` (par défaut `dossier wads dans le référentiel wapt`) | Définit le dossier sur le serveur WAPT qui stocke les fichiers relatifs aux WADS. | wads_folder = /var/www/waptwads
`wapt_folder` (par défaut `/var/www/wapt` ou `/var/www/html/wapt` ou `root_dir/waptserver/repository/wapt`) | Définit le chemin d’accès au répertoire du référentiel WAPT. | wapt_folder = /var/www/wapt
`wapt_huey_db` (défaut `None`) | 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
`waptwua_folder` (défaut wapt_folder + “wua”) | Définit l’emplacement du dossier WAPT WUA. | waptwua_folder = /var/www/waptwua
`ipxe_script_jinja_path` (défaut `/opt/wapt/waptserver/templates/ipxe-default.j2`) | 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

Activation/Désactivation de paramètres

Options (valeur par défaut) | Description | Exemple
--- | --- | ---
`login_auth_methods` (default= [“session”, “admin”, “passwd”, “ldap”]) | Définit le type de connexion utilisé pour accorder l’accès à la console WAPT, à certaines API et à WADS. | login_auth_methods = [“session”, “admin”, “passwd”, “ldap”]
`allow_unauthenticated_connect` (par défaut `None`) | Définit si les connexions websocket doivent être authentifiées. Si `use_kerberos` = `True`, alors `allow_unauthenticated_connect` DEVAIT ETRE positionné à `False` ou il sera prioritaire. | allow_unauthenticated_connect = True
`allow_unauthenticated_registration` (défaut `False`) | Permet l’enregistrement initial de l’agent WAPT à l’aide d’un login et d’un mot de passe. | allow_unauthenticated_registration = True
`allow_unsigned_status_data` (défaut `False`) | Débogage uniquement - Permet à l’agent d’envoyer des données d’état non signées. | allow_unsigned_status_data = True
`optimized_authentication_logs` (défaut `True`) | Si l’une des options est définie, elle ne sera pas enregistrée : `waptagent_version`, `host_tasks_status`, `get_ad_groups`, `get_ad_sites`, `get_ad_ou_split`, `host_data`, `get_hosts` , `audit_data`, `wsus. windows_updates`, `wsus.windows_products`, `wsus.windows_updates_classifications`, `packages_for_hosts`, `enterprise.reporting_exec`, `known_packages`, `repositories. get_all_agentrepos`, `repositories.get_sync_version`, `repositories.get_all_rules`, `get_all_users_acls`, `known_signers_certificates`, `enterprise.reporting_list`, `usage_statistics`, `repositories.get_createupdatefilesync`, `repositories.get_sync_changelog`, `licences` | optimized_authentication_logs = False
`auto_create_waptagent_from_config` (défaut `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
`cleanup_kbs` (défaut `True`) | Définit si les :ref:` Windows KB inutilisés doivent être automatiquement supprimés <auto_kb_clean>` du serveur WAPT. | cleanup_kbs = False
`copy_winpe_x64_in_tftp_folder` (défaut `False`) | Si x64, permet de copier tous les WinPE à partir de `wads_folder` lorsque WinPE est téléchargé. | copy_winpe_x64_in_tftp_folder = True
`download_wsusscn2` (défaut `True`) | Télécharge automatiquement le fichier `wsusscn2.cab`. | download_wsusscn2 = False
`enable_store` (par défaut False`) | Active WAPT Store Webui (Deprecated). | enable_store = False
`encrypt_host_packages` (défaut `False`) | Crypte le paquet de l’hôte avec le certificat du client. | encrypt_host_packages = True
`login_on_homepage` (default `True`) | Activé ou désactivé l’authentification de la page d’acceuil du serveur wapt. | login_on_homepage = True
`homepage_enable` (défaut `True`) | Activé ou désactivé la page d’acceuil du serveur wapt. | homepage_enable = True
`ldap_nesting_group_support` (défaut `True`) | Permet la recherche de groupes imbriqués dans Active Directory. | ldap_nesting_group_support = False
`ldap_primary_group_ad_support` (défaut `True`) | Active la recherche sur les utilisateurs du groupe primaire d’Active Directory. | ldap_primary_group_ad_support = False
`login_on_wads` (défaut `False`) | Active l’authentification pour utiliser WADS (le format est `utilisateur:mot de passe`). | login_on_wads = True
`optimized_authentication_logs` (défaut `True`) | Si l’une des options est définie, elle ne sera pas enregistrée : `waptagent_version`, `host_tasks_status`, `get_ad_groups`, `get_ad_sites`, `get_ad_ou_split`, `host_data`, `get_hosts`, `audit_data`, `wsus.windows_updates`, `wsus.windows_products`, `wsus.windows_updates_classifications`, `packages_for_hosts`, `enterprise.reporting_exec`, `known_packages`, `repositories.get_all_agentrepos`, `repositories.get_sync_version`, `repositories.get_all_rules`, `get_all_users_acls`, `known_signers_certificates`, `enterprise.reporting_list`, `usage_statistics`, `repositories.get_createupdatefilesync`, `repositories.get_sync_changelog`, `licences` | optimized_authentication_logs = False
`remote_repo_websockets` (par défaut `True`) | Permet la communication par websocket avec les agents WAPT configurés en tant que dépôts distants. | remote_repo_websockets = False
`use_kerberos` (défaut `False`) | Permet à un agent WAPT de s’enregistrer en utilisant son compte kerberos. Si `use_kerberos` = `True`, alors `allow_unauthenticated_connect` DEVAIT ETRE positionné à `False` ou il sera prioritaire. | use_kerberos = True
`use_ssl_client_auth` (défaut `True`) | Active authentification du certificat du client. | use_ssl_client_auth = True
`wads_enable` (défaut `False`) | Active la fonction WADS et active wapttftpserver. | wads_enable = True

Paramètres de base de données

Options (valeur par défaut) | Description | Exemple
--- | --- | ---
`db_connect_timeout` (défaut `3`) | Définit le délai maximum autorisé avant que les requêtes PostgreSQL n’expirent (en secondes). | db_connect_timeout = 10
`db_host` (défaut `None`) | Définit l’url du serveur PostgreSQL (par défaut WAPT utilise un socket Unix local). | db_host = https://wapt.mydomain.lan
`db_max_connections` (défaut `90`) | Définit le nombre maximum de connexions simultanées à la base de données PostgreSQL. | db_max_connections = 100
`db_name` (défaut `wapt`) | Définit la base de données PostgreSQL à laquelle le serveur WAPT se connecte. | db_name = wapt
`db_password` (défaut `None`) | 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
`db_port` (défault `5432`) | Définit le port du serveur PostgreSQL. | db_port = 5432
`db_stale_timeout` (défaut `300`) | Définit le délai d’expiration de la base de données (en secondes). | db_stale_timeout = 500
`db_user` (défaut `wapt`) | Définit l’utilisateur PostgreSQL qui se connecte à la base de données. | db_user = wapt

Paramètres de sécurité

Options (valeur par défaut) | Description | Exemple
--- | --- | ---
`client_certificate_lifetime` (défaut `3650`) | Définit la durée de vie du certificat d’hôte (en jours). | durée de vie du certificat du client = 500
`clients_read_timeout` (défaut `5`) | Définit le délai d’attente du client websocket (en secondes). | clients_read_timeout = 10
`clients_signing_crl_days` (défaut `30`) | Définit la périodicité (en jours) de la signature CRL du certificat de l’hôte. | clients_signing_crl_days = 15
`clients_signing_crl_url` (défaut `None`) | Définit l’URL de la CRL de signature du certificat de l’hôte. | clients_signing_crl_url = https://srvwapt.mydomain.lan/crl
`client_tasks_timeout` (défaut `5`) | Définit le délai maximum autorisé avant que les demandes de l’agent WAPT n’expirent (en secondes). | client_tasks_timeout = 5
`http_proxy` (défaut `None`) | Définit le serveur proxy permettant au serveur WAPT de récupérer sa CRL. | http_proxy = http://srvproxy.mydomain.lan:3128
`htpasswd_path` (défaut `None`) | Ajoute une authentification de base au serveur WAPT. | htpasswd_path = True
`list_subnet_skip_login_wads` (défaut `[]`) | 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
`loglevel` (défaut `warning`) | Définit le niveau de journalisation. Les valeurs possibles sont : `debug`, `info`, `warning`, `critical`. | loglevel = debug
`max_clients` (défaut `4096`) | Définit le nombre maximum de connexions clients WAPT simultanées. | max_clients = 2048
`min_password_length` (défaut `10`) | Définit la longueur minimale du mot de passe SuperAdmin. | min_password_length = 15
`secret_key` (défaut `None`) | 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
`server_uuid` (défaut `None`) | Définit le UUID du serveur WAPT (cet identifiant anonyme est utilisé pour les statistiques WAPT). | server_uuid = 76efezfa6-b309-1fez5-92cd-8ea48fc122dc
`session_lifetime` (défaut `126060`) | Définit la durée maximale d’ouverture de la session (en secondes). | session_lifetime = 352120
`signature_clockskew` (défaut `300`) | Définit la différence de temps maximale autorisée pour les websockets (en secondes). | signature_clockskew = 72000
`token_lifetime` (par défaut 43200) | Définit la durée de vie du jeton d’authentification (en secondes). | token_lifetime = 43200

Paramètres de réseau

Options (valeur par défaut) | Description | Exemple
--- | --- | ---
`nginx_http` (défaut `80`) | Définit le port HTTP du serveur web Nginx (Windows uniquement). | nginx_http = 8080
`nginx_https` (défaut `443`) | Définit le port HTTPS du serveur web Nginx (Windows uniquement). | nginx_https = 44380
`remote_repo_update_delay` (défaut `1`) | 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
`wapt_bind_interface` (défaut `127.0.0.1`) | Définit comment écouter le service du serveur WAPT. | wapt_bind_interface = 127.0.0.1
`waptserver_port` (défaut `8080`) | Définit le port du service python du serveur WAPT. | waptserver_port = 1313
`wol_port` (défaut `7,9`) | Définit la liste des ports UDP de WakeOnLAN auxquels envoyer des paquets magiques. | wol_port = 9, 123, 4000

Paramètres d'authentification

Options (valeur par défaut) | Description | Exemple
--- | --- | ---
`wapt_password` (par défaut None) | Définit le mot de passe SuperAdmin pour la connexion à la console WAPT. | wapt_password = 46642dd2b1dfezfezgfezgadf0ezgeezgezf53d
`wapt_user` (défaut `admin`) | Définit le nom d’utilisateur SuperAdmin dans la console WAPT. | wapt_user = wapt_admin

### 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

`nginx.conf` emplacement du fichier de configuration
Type d’OS | Emplacement du fichier
--- | ---
Debian et dérivés | `/etc/nginx/nginx.conf`
RedHat et dérivés | `/etc/nginx/nginx.conf`
Windows | `C:\wapt\waptserver\nginx\conf\nginx.conf`

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.

Les paquets sont stockés dans le répertoire `/var/lib/nginx/proxy`. Vous devez vous assurer que la partition hébergeant ce répertoire est suffisamment grande. Vous pouvez modifier l’emplacement de ce répertoire en utilisant le paramètre de configuration Nginx suivant.

    $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

`postgresql.conf` emplacement du fichier de configuration
Type d’OS | Emplacement du fichier
--- | ---
Debian et dérivés | `/etc/postgresql/version/main/postgresql.conf`
RedHat et dérivés | `/var/lib/pgsql/{version}/data/postgresql.conf`
Windows | `C:\wapt\waptserver\pgsql{version}_data\postgresql.conf`

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 `.crt` et `.pem` dans `/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.