Windows (WinRM) module
Deploy any file to any Windows path, then run PowerShell post-deploy scripts. The Windows sibling of the SSH module — same PathSet + ActionSet operator UX, different transport. Distinct from the IIS module, which is dedicated to IIS binding lifecycle.
Type: winrm Version: 1.0.0 Rollback: previous-version re-deploy
When to pick this module
Pick winrm when you want to:
- Drop a PEM / PFX / JKS / P7B / DER / arbitrary file at a known Windows path (
C:\inetpub\certs\site.pfx,\\fileserver\share\...). - Run PowerShell after — restart a service, import into a Java keystore via
keytool, run a custom hook script. - Cover Windows targets that aren't IIS: Tomcat, JBoss, custom .NET services, ad-hoc certificate stores.
If your only goal is to update an IIS HTTPS binding, the dedicated IIS module handles binding discovery, app-pool recycling, and old-cert cleanup automatically.
Minimum access
Give the account CertAutoPilot signs in with (the winrm_password credential, a domain or local Windows account) exactly this:
- Membership in the local Administrators group on each Windows server a target names. Windows opens the WinRM shell this module runs in for Administrators only.
- Modify (NTFS) on every folder a PathSet writes to. Administrators usually have it already; add it where a folder has its own ACL. A written file takes the folder's inherited permissions, so keep a folder that holds a private key restricted.
- Only for a local account other than the built-in Administrator, over NTLM or Basic:
LocalAccountTokenFilterPolicy = 1(Step 5). - Only for
auth_typekerberos: a domain account, with the server addressed by its AD host name. - Only for an ActionSet: whatever its own commands need, for example rights on the service it restarts. The module adds nothing on top.
Not needed: Domain Admin, CredSSP or Kerberos delegation, a JEA endpoint, or an execution-policy change. Remote Management Users alone is not enough — it opens the PowerShell remoting endpoint, not the WinRM shell (the server answers HTTP 500 … Access is denied). A non-administrator can connect only after the server's WinRM security descriptor (RootSDDL) is widened with (A;;GXGR;;;RM) and the account is in Remote Management Users; that was measured for the Windows DNS provider, which uses the same shell, but not with this module, and the account can then only write where its own NTFS rights allow.
# Elevated PowerShell on the Windows server
$acct = 'CORP\svc-certdeploy'
Add-LocalGroupMember -Group 'Administrators' -Member $acct
icacls 'C:\ProgramData\MyApp\ssl' /grant "${acct}:(OI)(CI)M" # each PathSet folder, when needed
Setup, step by step
Run each block on the target Windows host in an elevated PowerShell, then check the result before moving on. You don't need the big one-shot script — do it one step at a time.
Step 1 — Enable WinRM
Enable-PSRemoting -Force
Check the service is running:
Get-Service WinRM # Status should be "Running"
Step 2 — Pick your port (prefer HTTPS 5986)
See which listeners exist:
winrm enumerate winrm/config/Listener # look for Transport = HTTP (5985) / HTTPS (5986)
Recommended: use HTTPS on 5986. If there's no HTTPS listener, create one (needs a server cert whose name matches how CertAutoPilot will address the host):
# Server cert — DnsName MUST equal the host you'll enter in the CAP target (FQDN, or add the IP)
$cert = New-SelfSignedCertificate -DnsName "win01.corp.local" -CertStoreLocation Cert:\LocalMachine\My
New-Item -Path WSMan:\localhost\Listener -Transport HTTPS -Address * -CertificateThumbPrint $cert.Thumbprint -Force
Verify:
winrm enumerate winrm/config/Listener # now shows Transport = HTTPS, Port = 5986
Test-NetConnection -ComputerName localhost -Port 5986 # TcpTestSucceeded : True
You have AD CS? Enroll a Web Server / Server Authentication cert from your CA instead of self-signed — its root is already trusted, so CertAutoPilot won't need a TLS-trust override.
Plain HTTP 5985 also works (requires
AllowUnencryptedon the service — see the warning under Authentication; the auth handshake is protected but the WSMan body is not), but it's a more common source of confusing401errors — if you're troubleshooting, move to 5986 first. See the 401 walkthrough, which applies to this module too.
Step 3 — Open the firewall
If Windows Firewall is on, open the port you chose:
New-NetFirewallRule -DisplayName "WinRM HTTPS 5986" -Direction Inbound -Protocol TCP -LocalPort 5986 -Action Allow
If the firewall is off, skip this.
Step 4 — The account must be a local Administrator
The credential CertAutoPilot connects with must be in the local Administrators group: the default WinRM access control only admits Administrators, and the account must be able to write the PathSet paths and run whatever the ActionSet does (restart a service, update a keystore). This module never imports anything into the Windows certificate store — that is the IIS module's job.
net localgroup Administrators # the account (or its group) must be listed
Step 5 — Local admin on a host with UAC on? Set one registry value
Only if the account is a local admin (not a domain account) and UAC is enabled on the host (EnableLUA=1, the default): UAC then filters its token on a network logon. Fix it once:
New-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" `
-Name LocalAccountTokenFilterPolicy -Value 1 -PropertyType DWORD -Force
Domain accounts don't need this — they get their full admin token on a network logon. With UAC disabled the value has no effect either way.
Step 6 — Configure the target in CertAutoPilot
- Hostname: a bare host name, FQDN or IP. Saving refuses a URL or a path (each used to surface only as a deploy-time "no such host"). A port typed into the field (
win01:5986) is moved into the port field, and refused only when it contradicts it; brackets around an IPv6 address are dropped, while unbalanced brackets, or an unbracketed IPv6 address ending in:5985/:5986(write[fd00::5]:5986), are refused. Each refusal is an HTTP 400 naming the field. A target saved before these checks keeps its hostname, port and TLS setting as they are for as long as you leave those three unchanged — only a changed endpoint is checked. - Use TLS: on (port 5986) — or off if you chose 5985. Saving refuses the two mismatches (TLS on with
5985, TLS off with5986): WinRM answers them with a reset or a protocol error, never with a hint. - Auth:
NTLM(recommended). Only useBasicif you deliberately enabled it (Step 2 note) — Basic on plain HTTP needsAllowUnencrypted=trueand sends credentials in cleartext. - Username: the bare account name in the credential; the target's Domain field decides the wire form — with a domain it is sent as
DOMAIN\user, without one as.\user(explicitly local). Basic needs the bare name too; a name you qualify yourself (DOMAIN\user,user@realm) is sent verbatim for NTLM and refused for Kerberos. - TLS verification: the listener certificate is verified against the CertAutoPilot host's trust store; there is no per-target CA field. With a self-signed 5986 cert either trust it on the CertAutoPilot host or set
tls_skip_verifyon the target (every deploy then logs a warning — the connection accepts any certificate).
Step 7 — Verify
Run the target's Test connection first: it reports what the host lacks (language mode, a PowerShell older than 3) with the fix for each, and lists as warnings — shown in the result, they do not fail the check — a non-administrator or UAC-filtered account, an unwritable %TEMP%, a lowered message-size limit (with the largest transfer that still fits) and a PowerShell older than the tested 5.1. Then deploy a test distribution with the exact CAP account. The client sends transfers in pieces of ~150 KB of payload, ~201 KB per request once encoded — below WinRM's default MaxEnvelopeSizekb of 500; a host that lowered it is warned about by the check and, at deploy time, a refused transfer is reported as WINRM_QUOTA (Windows answers HTTP 413) — restore the default with winrm set winrm/config '@{MaxEnvelopeSizekb="500"}'.
Authentication methods
AllowUnencrypted — for every auth typeCertAutoPilot's WinRM clients authenticate the connection but do not encrypt the WSMan
message body. Over HTTP 5985 the WinRM service only accepts such requests when
AllowUnencrypted is enabled on the target — this applies to NTLM, Basic and Kerberos
alike (a missing setting typically surfaces as an empty HTTP 500 after auth succeeds):
Set-Item WSMan:\localhost\Service\AllowUnencrypted $true
Restart-Service WinRM
Over HTTPS 5986 this is not needed (TLS protects the body) — prefer 5986 in production.
NTLM (default)
Works with local accounts and domain accounts. Enter just the account name: with the target's Domain field set it is sent as DOMAIN\user; with Domain empty it is sent as .\user (explicit local account). A name you qualify yourself (DOMAIN\user, user@fqdn, .\user) is used verbatim.
Basic
Username/password sent over the wire. Use only with TLS enabled — the target form warns when you mix Basic with plain HTTP.
Kerberos (first-class, zero-config)
Set auth_type=kerberos and the Domain field to the Kerberos realm (uppercase, e.g.
CORP.LOCAL). Address the target by its AD FQDN (web01.corp.local) — never an IP: the SPN is
auto-derived as HTTP/<hostname>, and the KDC has no service principal for a bare IP
(KDC_ERR_S_PRINCIPAL_UNKNOWN).
That is the whole setup. There is no krb5.conf to create, mount, or point KRB5_CONFIG at —
CertAutoPilot builds its Kerberos configuration in memory and discovers the domain controller
automatically from the _kerberos._tcp.<REALM> DNS SRV record that every Active Directory domain
publishes.
The remaining prerequisites are environmental, not product setup:
- DNS — the CertAutoPilot host must resolve AD DNS: the target's FQDN and the realm's SRV
records. In a corporate network that is normally already true. If this host's DNS cannot
resolve AD records, fill the optional KDC Address field on the target (
hostorhost:port) to pin the domain controller explicitly — still a form field, never a file. - TCP 88 to a domain controller — the ticket request goes to the KDC over TCP only (no UDP, no port 464). See Outbound network access.
- FQDN targeting — connect by hostname, not IP (SPN requirement above).
- Time sync — Kerberos tolerates ±5 minutes of clock skew; any NTP-synced host qualifies.
- On plain HTTP (5985):
AllowUnencryptedon the target — see the warning at the top of this section; Kerberos is not exempt. Not needed over HTTPS 5986.
Verify from the CertAutoPilot host if in doubt: getent hosts web01.corp.local and
nc -z -w3 <dc> 88 both succeed.
CertAutoPilot's Kerberos client explicitly disables PA-FX-FAST negotiation, which stock Windows
KDCs do not answer — without that, a password login fails with KDC_ERR_PREAUTH_FAILED even though
the password is correct. No action needed; this is handled for you.
On a domain member locked down with Network security: Restrict NTLM: Incoming NTLM traffic (a
common domain GPO), the WinRM listener rejects NTLM and every auth attempt 401s. Either allow
incoming NTLM in the domain GPO (RestrictReceivingNTLMTraffic = 0 — a local registry override
reverts on the next gpupdate) or switch to Kerberos (above), which needs no change on the box
and no setup on the CertAutoPilot host. The IIS 401 guide has the full
walkthrough.
CredSSP (multi-hop delegation) is not supported in this version. Most domain-joined scenarios are covered by Kerberos.
Something failed — read the message
Every connection or authentication failure names its layer and the fix: nothing is listening on …, answers plain HTTP but this target has TLS enabled, winrm refused the request: HTTP 401 (server offers …), and so on. The full symptom → cause → fix catalogue, verified on a live Windows Server, is on WinRM troubleshooting.
Worked before the upgrade, 401 now?
A bare username with an empty Domain used to be sent unqualified — a domain-joined server
could resolve it as a domain account. Since 1.5.49 it is sent as .\user (explicitly local).
If that was your setup, set Domain on the target or write the username as DOMAIN\user.
The worker log records the assembled wire username at debug level.
PathSet — where files go
The PathSet (and ActionSet) you bind to a WinRM target must be created with target_kind: "windows". The form's PathSet/ActionSet dropdowns filter to Windows-scoped resources only; the backend rejects mismatched bindings at create/update time. Reusing a Linux PathSet on a WinRM target (or vice versa) is not allowed — POSIX paths and owner/mode have no Windows equivalent.
Identical shape to the SSH module's PathSet. Each entry pairs a content source with an absolute Windows path. Sources:
cert— leaf certificate PEMchain— chain (intermediates) PEMfullchain— leaf + chain PEMprivate_key— private key PEM; with apassphrase_variableit is written as an encrypted PKCS#8 PEMcombined— leaf + chain + key in one PEM filepfx— PKCS#12 bundle (leaf + chain + key), protected with the secret project variable named inpassphrase_variablejks— Java KeyStore (leaf + chain + key), keystore and entry password frompassphrase_variable, entry named byalias(default: the primary domain)p7b— PKCS#7 chain bundle (leaf + intermediates, no key)
Format defaults to pem; der is supported for cert, an unencrypted private_key and p7b (pfx and jks take no format). pfx, jks and an encrypted key are rebuilt with a fresh salt on every run, so they are uploaded every time; a p7b is skipped when unchanged.
Path validation rejects: relative paths, .. traversal segments (a .. inside a name such as a..pem is fine), null bytes, Windows reserved device names (CON, NUL, PRN, AUX, COM1–9, LPT1–9), forbidden filename characters (< > : " | ? *), components with trailing dots or spaces (Windows strips them silently), and paths longer than 252 characters. Drive-letter and UNC paths are both accepted.
The length limit is Windows' own 259-character maximum minus the seven characters of the staging suffix the transfer appends: the file is written beside its destination and moved into place only after the content check, so the staging name has to fit too. A longer path is refused before anything is sent.
ActionSet — what runs after
By default the ActionSet runs only when a deployed file actually changes (hash-based skip), so restart/reload actions stay idempotent on no-op redistributes. Set run_always on the ActionSet to run it on every distribution even when nothing changed — for verification/diagnostic actions that must run each time (e.g. printing the deployed certificate). When it runs despite no change the log shows no file changed, running anyway (run_always enabled).
Two modes:
command mode
List of PowerShell commands. Run one-by-one, each as its own powershell.exe -EncodedCommand process. Optional allowed_commands regex allowlist (defence in depth — operator mistypes a destructive command and the regex blocks it): each command is matched after variable substitution, patterns are unanchored (use ^…$), and each must be a valid regex of at most 512 characters — refused at save. If a stored pattern still cannot be used at deploy, the target fails with WINRM_VALIDATION and no command runs; the list never falls back to "allow everything". A command outside the list also fails the target with WINRM_VALIDATION.
script_inline mode
Multi-line script body. Uploaded to a remote temp path ($env:TEMP\certautopilot-XXXX.ps1) via the file transport, ACL-restricted to the executing user, run with -NoProfile -NonInteractive -ExecutionPolicy Bypass -File, then removed (best-effort cleanup).
Operator picks the shell: powershell.exe (Windows PowerShell 5.1, default — present on every modern Windows Server) or pwsh.exe (PowerShell 7+, must be installed on the target).
Variable substitution
Project variables expand via the ${{ NAME }} placeholder syntax. Values are PowerShell-escape-aware: a hostile project variable value $(Get-Process) is substituted as the literal string '$(Get-Process)' rather than an executable sub-expression. Same threat-model fix as the SSH module's shell-escape work; consult project variables for syntax details and escape semantics.
Worked example: cert + Tomcat reload
A PathSet row with source jks writes the Java keystore itself (password from a secret variable), so the conversion below is only needed when you want openssl / keytool to build it on the server — for example to add the entry to an existing keystore. See Java KeyStore.
PathSet:
C:\Tomcat\conf\ssl\fullchain.pem→ sourcefullchainC:\Tomcat\conf\ssl\privkey.pem→ sourceprivate_key
ActionSet (mode script_inline, shell powershell.exe; KEYSTORE_PASS is a secret project variable — substituted values arrive already single-quoted, so do not add quotes around the placeholder). keytool cannot read PEM directly, so the PEM pair is converted to PKCS#12 first, and both tools take the password from an environment variable rather than a command-line argument:
$ErrorActionPreference = 'Stop'
$env:KS_PASS = ${{ KEYSTORE_PASS }}
# PEM → PKCS#12 (password read from the environment, never on the command line)
& openssl pkcs12 -export `
-in "C:\Tomcat\conf\ssl\fullchain.pem" `
-inkey "C:\Tomcat\conf\ssl\privkey.pem" `
-name tomcat `
-out "C:\Tomcat\conf\ssl\keystore.p12" `
-passout env:KS_PASS
# PKCS#12 → JKS for Tomcat
& keytool -importkeystore -noprompt `
-srckeystore "C:\Tomcat\conf\ssl\keystore.p12" -srcstoretype PKCS12 -srcstorepass:env KS_PASS `
-destkeystore "C:\Tomcat\conf\ssl\keystore.jks" -deststoretype JKS -deststorepass:env KS_PASS
Restart-Service -Name Tomcat9
Write-Output "tomcat reloaded with new cert"
(Or point Tomcat's connector at the .p12 directly and skip the JKS step.) Secret values are masked in the job log, but the rendered script runs on the host — keep the temp directory private.
Rollback
Supported via previous-version re-deploy: a rollback re-writes a previous retained certificate version's files via the PathSet and re-runs the ActionSet — the module's normal deploy path, fed older material. Whatever the ActionSet does (restart a service, import into a JKS, custom logic) simply runs again against the older files. Eligibility, the version picker, and auto-rollback: Rollback.
Limits + performance
| Knob | Default | Note |
|---|---|---|
| File transfer rate | ~60–300 KB/sec | WAN-RTT bound; the payload streams in on the command's standard input in a single round trip and is content-checked on the host. |
| Per-file size cap | 100 MB | Configurable on the target via max_file_size_bytes. Raise only if you genuinely need to push > 100 MB. |
| Inline script size | no cap | The script body is uploaded to the host as a file and run with -File. |
| Command-mode entry size | ~176 KB of text | A command whose launch line would exceed 8,000 characters (roughly 2,900 characters of PowerShell) is staged as a file on the host and run with -File automatically; the only cap is about 176 KB of script text, refused locally with WINRM_QUOTA. |
| Command output kept | 64 MiB | Standard output of one command the module runs itself (file transfer, checks); past it the command is stopped on the host and fails with WINRM_OUTPUT_LIMIT. Your ActionSet commands and scripts always run to their end, like on SSH: of a longer output the first 4 MiB and the last 12 MiB are kept (the job log then shows at most 16 KB, see Output truncation). Of standard error the first 4 MiB and the last 12 MiB are kept (a command is never stopped for it). |
| Per-target concurrency | 10 | Module-level concurrency, clamped to 1–50; forced to 1 when Parallel Execution is off in Settings → General. |
| Per-target timeout | 5 min | target_timeout_seconds on the module config. |
| Per-command timeout | 60 sec | command_timeout_seconds on the target caps a whole script_inline run; it does not cap command-mode entries, and the health check (30 s preflight) and dry-run probe (10 s) have their own bounds. ActionSet timeout_seconds (default: no limit) applies per command in command mode and to the whole script in script_inline mode. |
| Connect timeout | 15 sec | connect_timeout_seconds on the target bounds the TCP connect only. |
| Shell reuse | on | One WinRM shell serves a whole target's deploy (fewer round trips on slow links); set CERTAUTOPILOT_WINRM_SHELL_REUSE=false in the backend's environment to go back to a shell per command. |
| Kerberos login reuse | on | A Kerberos connection logs in to the domain controller once and reuses the ticket for every WinRM request of the run (measured: one deploy went from 217 domain-controller exchanges to about 20; with a slow domain controller the run no longer slows down per request). An unused login is closed after 60 s and renewed after 15 min; a request the host refuses (401) makes the next request log in afresh. Set CERTAUTOPILOT_WINRM_KERBEROS_LOGIN_CACHE=false in the backend's environment to go back to a login per request. |
| Response wait | ≥ 60 sec | Every WinRM request other than an output poll waits at least 60 seconds (or the connect timeout, if longer) for the host's answer, so a busy host opening a shell is not reported as a connect failure. A timeout names which half ran out: "could not connect … within N s" or "accepted the connection but did not answer … within N s". |
| Reply body | ≥ 60 sec | Once the host has started its answer, the rest of it must arrive within the same wait; a TLS handshake within the connect timeout. A host that sends its answer a byte at a time, never reads the request or never finishes the handshake ends that request instead of holding it. |
| Output poll wait | 60 sec (+15 sec margin) | While a command runs, the host may hold each output poll open for up to 60 seconds, so a command that prints nothing for a while neither fails nor loses its output. |
| Health check | connect + 35 sec per target | Inside the check's overall 100 s; a target it had no time left for is reported not checked. |
| Output truncation | 16 KB | Per-command stdout+stderr; PowerShell verbosity bounded. Redacted before it is logged (PEM keys, base64 runs, credential shapes, hex-encoded key material incl. dash-separated [BitConverter]::ToString output). |
Error codes
The module emits structured WINRM_* error codes for retry classification:
WINRM_CONNECT— dial / DNS / connection refused or reset (network class — retried)WINRM_AUTH— 401, NTLM/Kerberos rejection, "Access denied", and TLS handshake / certificate errors on the listener (auth class — not retried)WINRM_TIMEOUT— a deadline expired or the run was cancelled (transient — retried)WINRM_EXEC— non-zero PowerShell exit without a recognised cause (transient — retried)WINRM_PS_SYNTAX— PowerShell parse error or "is not recognized" in the error text or the failed ActionSet output (validation — not retried)WINRM_FILE— a file could not be written on the host: parent directory, transfer, content-check mismatch, or "access is denied" on the destination (transient — retried)WINRM_VALIDATION— operator configuration error: unresolved PathSet/ActionSet, invalid path or missing variable, missing/non-secret passphrase variable (pfx, jks, encrypted key), invalid or absent shell, a command rejected byallowed_commandsor an unusable pattern (validation — not retried)WINRM_OUTPUT_LIMIT— a command the module runs itself printed more than 64 MiB on standard output and was stopped on the host (permanent; a misbehaving or hostile host). ActionSet commands are never stopped for their output.WINRM_QUOTA— MaxEnvelopeSize exceeded (Windows answers HTTP 413 — the size, not the credential, was refused), or a file overmax_file_size_bytes(permanent — operator must raise the quota)WINRM_HOST_PREREQ— the host cannot run the scripts as it is: Constrained Language mode, or a PowerShell older than 3, which cannot run the file transfer (a non-administrator or UAC-filtered token, an unwritable%TEMP%, a lowered envelope limit and PowerShell 3 or 4 are warnings for this module; a transfer the envelope limit refuses isWINRM_QUOTA); found by the health-check preflight or at deploy time, the message names the fix (validation — not retried)
A message that starts with one of these codes (for example WINRM_VALIDATION: file path must be absolute) is recorded under that code. WINRM_CONNECT/WINRM_EXEC are generic wrappers, so a 401 or TLS error inside them is still recorded as WINRM_AUTH.
vs. the IIS module
| Aspect | winrm | iis |
|---|---|---|
| Scope | Generic file deploy + script | IIS binding lifecycle |
| PathSet / ActionSet | Yes | No (uses fixed IIS scripts) |
| Concurrency | Parallel (10 default, clamped 1–50; 1 when Parallel Execution is off) | Sequential |
| Auth | NTLM, Basic, Kerberos | NTLM, Basic, Kerberos |
| Rollback | Yes (previous-version re-deploy) | Yes (previous-version re-deploy) |
| Picks IIS bindings automatically | No (operator scripts it) | Yes |
Multi-certificate hosts
Two mechanisms let one WinRM target serve many certificates:
- Per-distribution PathSet/ActionSet — each certificate's distribution can select its own PathSet (where files land) and ActionSet (what runs afterwards) from the certificate's Distributions → Overrides drawer (
winrm { path_set_id, action_set_id }, with a*default row). A selected override must resolve — a deleted or wrong-kind resource fails the run instead of silently using the target's own libraries. - Certificate-context variables in paths — PathSet paths may contain
${{ CAP_PRIMARY_DOMAIN }},${{ CAP_DOMAIN_SLUG }},${{ CAP_CERT_TOKEN }}or${{ CAP_DEPLOY_NAME }}, rendered per certificate at distribution time:C:\\certs\\${{ CAP_DOMAIN_SLUG }}\\bundle.pfx. UseCAP_DOMAIN_SLUG, notCAP_PRIMARY_DOMAIN, in Windows paths:*is invalid in Windows file names, so a wildcard certificate's primary domain (*.example.com) always fails, while the slug renders asexample-com. Project variables also render; secret variables are rejected in paths; a missing variable fails that target. Note that substitution always applies: a literal${{ ... }}in a path or command must be escaped with a backslash (\${{ ... }}). (A rollback re-deploys the previous version through the same PathSet rendering.)
When several certificates share a host, put ${{ CAP_CERT_TOKEN }} or ${{ CAP_DEPLOY_NAME }} in the path (or use distinct PathSets) so files never collide.
Who may choose and run it. Choosing or changing a distribution's PathSet or ActionSet in the Overrides drawer needs the Admin role, and so does running or rolling back by hand a distribution whose targets or overrides run an ActionSet — both decide which administrator-written commands run on which hosts. An Operator gets 403 ACCESS_DENIED, or an approval request for an admin when the project's approval policy gates that Operator's distribution actions. The automatic run after a renewal is not affected.
Video tutorials
Short, hands-on videos showing this feature working for real. English audio, English and Turkish subtitles. All video tutorials →