Microsoft IIS module
Deploys certificates to Windows Server IIS over WinRM: imports the PKCS#12 into the local machine certificate store and updates the site's HTTPS binding(s) — one binding, all matching bindings, or an explicit host-header list. Works with Windows Server 2016+.
Overview
- Transport: WinRM (HTTP 5985 or HTTPS 5986).
- Auth: NTLM (default), Basic, or Kerberos — set on the target (aligned with WinRM/Exchange); the credential carries only username + password. (Credentials created before 1.5.49 may still carry auth fields — they are honored when the target sets no auth type.) Over plain HTTP 5985 every auth type additionally needs
AllowUnencrypted=trueon the target machine (the client does not encrypt the WSMan body); over HTTPS 5986 it is not needed. - Artifact: PKCS#12 bundle (cert + private key + chain) generated on the fly, imported into
Cert:\LocalMachine\<store>. It is encrypted with TripleDES-SHA1 under a random one-time 256-bit password, because Windows Server 2016 cannot open an AES-encrypted PKCS#12 ("The specified network password is not correct."). The file is deleted right after the import. - Binding: updates the IIS site's HTTPS binding to reference the new thumbprint; the old certificate is left in the store unless Remove old cert after bind is on.
- Rollback: supported — a rollback re-imports a previous retained certificate version's PFX into the store and repoints the bindings (Rollback).
Prerequisites
Minimum access
Give the account CertAutoPilot signs in with (the iis_winrm credential, a domain or local Windows account) exactly this:
- Membership in the local Administrators group on each IIS server a target names. That one membership covers everything the module does: opening the WinRM shell, writing its temporary files in
C:\Windows\Temp, importing intoCert:\LocalMachine\MyorWebHosting, changing the HTTPS binding, recycling an application pool and removing the old certificate. - Only for a local account other than the built-in Administrator, over NTLM or Basic:
LocalAccountTokenFilterPolicy = 1on the server (see below). - Only for
auth_typekerberos: a domain account, with the server addressed by its AD host name.
Not needed: Domain Admin, any right in Active Directory, IIS Manager users or the Management Service (WMSvc), CredSSP or Kerberos delegation, or an execution-policy change. Remote Management Users alone is not enough (see below).
# Elevated PowerShell on the IIS server
Add-LocalGroupMember -Group 'Administrators' -Member 'CORP\svc-certdeploy'
Server setup
Missing any of these produces a WinRM error at deploy time — see Troubleshooting for the exact symptom each one causes.
-
WinRM enabled on the target:
Enable-PSRemoting -Force. Reachable on 5985 (HTTP) or 5986 (HTTPS) from the backend, with a firewall rule opening that port. For HTTPS WinRM the listener needs a valid server cert bound (winrm quickconfig -transport:https, or create the listener against an existing cert's thumbprint). -
WebAdministrationPowerShell module — the module runsImport-Module WebAdministrationon the target. It ships with the IIS Management Scripts and Tools feature:Install-WindowsFeature Web-Scripting-Tools. Without it you getIIS_MODULE_MISSING. (This is not the "Management Service"/WMSvc — the module uses WinRM + PowerShell, not the IIS remote-management extension.) -
A local Administrator account for the credential. Remote Management Users is not enough: that group grants the PowerShell remoting endpoint, while CertAutoPilot runs its commands through the WinRS shell, which the default security descriptor (
RootSDDL) grants to Administrators only — such an account authenticates and is then refused withHTTP 500 … Access is denied(reproduced live). And the module's operations —Import-PfxCertificateintoCert:\LocalMachine\Myand the IIS binding update — require Administrator (Remote Management Users lets you connect but the cert import then fails). A constrained JEA endpoint does not help: it is a PowerShell remoting endpoint, and the module never uses one. -
LocalAccountTokenFilterPolicy = 1— required when the credential is a local admin account on a host where UAC is enabled (EnableLUA=1, the default). Without it UAC filters the admin token on a network logon, so the connection is not treated as an administrator and WinRM denies the operation with "Access is denied" → the module reportsIIS_AUTH … HTTP 401. (With UAC disabled the setting has no effect — verified on a live host.) Set it once:New-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System' `-Name LocalAccountTokenFilterPolicy -Value 1 -PropertyType DWORD -Force(No effect for the built-in Administrator or domain accounts; needed for other local admins over NTLM.)
-
Auth method + username format must match the target's WinRM config:
- NTLM (default, recommended): username
.\userfor a local account, orDOMAIN\user. No server-side auth changes needed on the default WinRM configuration. Note that the client authenticates with NTLM but does not encrypt the WSMan message body, so over plain HTTP 5985 the service needsAllowUnencrypted="true"(see Troubleshooting); prefer HTTPS 5986 in production. - Basic: username is the bare
user(no.\— Basic cannot parse the.\prefix). RequiresBasic="true"on the WinRM service, plusAllowUnencrypted="true"for HTTP or a working HTTPS 5986 listener. (Large transfers work over NTLM too — see Troubleshooting.)
- NTLM (default, recommended): username
-
IIS installed with the HTTPS binding(s) the certificate should land on already in place. The module never creates a binding, in any placement mode; with no matching binding the run fails with
IIS_BINDING_NOT_FOUND.
Setup, step by step
The IIS module connects over WinRM, so the transport setup is the same as the WinRM module — step by step. Do those 6 steps first (enable WinRM → prefer HTTPS 5986 → firewall → local admin → LATFP if a local admin over NTLM → CAP target auth = NTLM DOMAIN\user), then add the two IIS-specific ones below. Run each on the target IIS server, elevated, and check the result before moving on.
Step A — Install the IIS scripting tools
The module runs Import-Module WebAdministration on the target; without it you get IIS_MODULE_MISSING.
Install-WindowsFeature Web-Scripting-Tools
Check:
Get-Module -ListAvailable WebAdministration # should list the module
Step B — Confirm the site has an HTTPS binding
single / all_matching modes update an existing HTTPS binding — they never create one.
Import-Module WebAdministration
Get-WebBinding | Where-Object protocol -eq 'https' # at least one row for the target site
If there's none, add one in IIS Manager (or with New-WebBinding) before deploying.
Step C — Create the credential + target in CertAutoPilot
Then follow Create the module credential and Create an IIS target below.
Create the module credential
- Settings → Distribution → Credentials → New.
- Module type: IIS (WinRM).
- Username and password — just the account name, no
DOMAIN\\prefix (the domain/realm comes from the target; a prefixed name is used as-is). - Save. The auth method itself (NTLM / Basic / Kerberos + Realm / KDC Address) is chosen on the target, not here.
Create an IIS target
- Settings → Distribution → Targets → New. Module: IIS.
- Fields:
- Hostname — reachable from the backend. A bare host name, FQDN or IP — saving refuses a URL (
https://…) or a path, because each failed the first deploy with a message about the network instead of the field. A port typed into it (win01:5986) is moved into Port (refused only when the two disagree); 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. - Port — defaults to
5986(HTTPS) /5985(HTTP) based on the Use TLS toggle. Saving refuses the two mismatches WinRM never answers helpfully: TLS on with5985, TLS off with5986. A target saved before this check (for example behind a port-forward) stays editable as long as its hostname, port and TLS setting are left unchanged. - Use TLS — on for 5986. Strongly recommended.
- TLS skip verify — accept self-signed WinRM listener cert. OK for initial bring-up, disable for prod.
- Auth Type —
ntlm,basic, orkerberos; leave empty to use the credential's auth fields (legacy). Setting it here overrides the credential'sauth_type/domain/kdc_hostas a group. For Kerberos, set the Realm (and optionally a KDC Address) and address the target by its AD FQDN, never an IP. With Kerberos, each WinRM connection logs in to the domain controller once and reuses the ticket for its requests (an unused login is closed after 60 s);CERTAUTOPILOT_WINRM_KERBEROS_LOGIN_CACHE=falsein the backend's environment goes back to a login per request. - Credential: pick the one from the step above.
- Certificate store: usually
WebHostingorMy(Personal). - Placement: Single binding (exact) — site name + binding IP (
*= All Unassigned) + port (default 443), with a Host Header sub-mode (auto-select / no-SNI / specific hostname) — or Filtered selection — sites (one, a list, or every site), IPs, ports and host headers combined freely. See Binding placement below. - Remove old cert after bind: optionally delete the previously bound certificate from the store after a successful bind — only if no other IIS SSL binding still references it.
- Verify Binding Names (
verify_binding_names, off by default): refuse to put the certificate on a binding it does not serve — see Binding name check. A distribution can force it on or off for its own certificate. - Connect timeout / Command timeout: default 15 s / 60 s (allowed 5–120 s and 10–300 s). While a command runs, the host may hold each output poll open for up to 60 s (CertAutoPilot waits 60 s plus a 15 s margin), so a command that prints nothing for a while neither fails nor loses its output; every other request keeps these timeouts. 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.
- App pool name (
app_pool_name) — comma-separated pool names. When set it overrides auto-detection: exactly these pools are recycled, regardless of which bindings changed. - Restart app pool (
restart_app_pool) — recycle the pool(s) after a successful binding update. Off by default. - Restart scope (
restart_scope) —site_only(default) orsite_and_subapps. - Certificate store (
cert_store) —My(default) orWebHosting; nothing else is accepted. - Per-host deploy timeout (
target_timeout_seconds, 30-3600): the whole time budget for deploying to one host (upload → import → bind → validate → app-pool recycle). Blank/0 = auto (5× the command timeout + 30 s). Raise it for slow hosts or a large PFX over slow WinRM.
- Hostname — reachable from the backend. A bare host name, FQDN or IP — saving refuses a URL (
- Save, then click Test connection on the target (or Health Check on the module): it runs the preflight over WinRM and reports anything the host lacks for a deploy (administrator token, WebAdministration, language mode, …) with the fix, plus warnings such as a lowered envelope limit — see WinRM troubleshooting.
Binding placement
The placement says which existing HTTPS bindings a run updates. The target form offers two ways to write it:
- Single binding (exact) —
apply_mode: single(the default). One site, one Binding IP + Port and the Host Header sub-mode select exactly one binding. More than one match fails withIIS_BINDING_AMBIGUOUS, none withIIS_BINDING_NOT_FOUND. - Filtered selection —
apply_mode: selector. Independent filters for sites, IPs, ports and host headers, combined freely: some sites, every site, every site on some ports, some sites on some IPs, only these host headers, and so on.
Filtered selection
| Field | Effect |
|---|---|
| Sites | Exactly one of: site_name (one site), site_names (a list, up to 100) or all_sites: true (every site on the machine, stopped ones included). With every site, excluded_sites (up to 100) skips named sites by their exact name (case-insensitive). An excluded site the server does not have is skipped with the warning IIS_EXCLUDED_SITE_NOT_FOUND (the job log names it) and the run goes on — a list shared through a distribution override's Default or group row names sites some servers do not have. One exception stops the run before anything is imported: an excluded site that a previous deploy recorded and that was renamed to a site this placement would bind fails with IIS_SITE_RENAMED — otherwise it would be swept up. A rename CertAutoPilot cannot prove (nothing recorded, see below) is not caught: after renaming an excluded site, update excluded_sites. A named site that does not exist fails the run with IIS_SITE_NOT_FOUND (site(s) not found: … for a list); one that was renamed in IIS fails with IIS_SITE_RENAMED, naming the new name. Any site name works, apostrophes and brackets included. |
binding_ips | Only bindings on these IPv4 addresses (up to 32). Empty — or * in the list — means any IP. IPv6 addresses are refused: IPv6 bindings cannot be selected. |
binding_ports | Only bindings on these ports (up to 50). Empty means any port. |
host_headers | Only bindings with these host headers (up to 100), exact names, case-insensitive, a trailing dot ignored. Empty means any host header, the one without a host header included. Wildcards are not expanded: *.example.com matches only an IIS binding whose host header is literally *.example.com. |
include_catch_all | With host_headers: also take the binding that has no host header. Refused without host_headers (an empty list already takes it). |
excluded_bindings | Host headers to skip (up to 100), reported as excluded and left untouched. A header cannot be both listed and excluded. |
expect_single | Exactly one binding must be selected: none fails with IIS_BINDING_NOT_FOUND, more than one with IIS_BINDING_AMBIGUOUS. Needs one site (refused with every site or a site list). |
A binding is selected when it is an HTTPS binding on a site in scope and passes
every filter; the lists are normalised when saved (sorted, de-duplicated, host
headers lower-cased). A listed host header that no selected binding carries is
reported as no such binding and makes the run partial. With the selection, the
legacy single-value fields binding_ip, binding_port and host_header are
refused (use the lists), and the selection-only fields (site_names, all_sites,
binding_ips, include_catch_all, expect_single) are refused in every other mode.
Examples:
| Goal | Selection |
|---|---|
| Every site, port 443 | all_sites: true, binding_ports: [443] |
| Every site except the admin site, ports 443 and 8443 | all_sites: true, excluded_sites: ["Admin Site"], binding_ports: [443, 8443] |
| Two sites, only one IP | site_names: ["Shop", "Portal"], binding_ips: ["10.0.0.5"] |
| These host headers wherever they are, plus each site's catch-all | all_sites: true, host_headers: ["a.example.com", "b.example.com"], include_catch_all: true |
| One site, exactly one binding on port 8443 | site_name: "Shop", binding_ports: [8443], expect_single: true |
A selection over every site touches each non-excluded site whose bindings pass the filters. Dry Run and the placement preview list the bindings before anything changes — always run one before the first execute.
Earlier modes
Targets saved with all_matching, explicit_list or all_sites keep working and
select exactly the bindings they did before — the API still accepts them, and the
deploy, Dry Run and preview run them through the same matcher as a selection. The
target form opens them as a Filtered selection and saves them as one:
| Earlier mode | Same selection |
|---|---|
all_matching (a site, Binding IP, binding_ports or Binding Port, excluded_bindings) | that site, that IP (* = any), those ports |
explicit_list (a site, Binding IP + Port, host_headers) | that site, IP, port and host headers |
all_sites (excluded_sites, Binding IP, binding_ports or Binding Port, excluded_bindings) | every site with the same exclusions, IP and ports |
The override drawer does the same for a legacy port or host-header row: it opens as a Filtered selection and is saved back as one.
One difference to know before re-saving an explicit_list target or a host-header
override row: it bound the first binding carrying each listed host header, while a
selection binds every binding that passes the filters. The two differ only when
one host header is bound on several IPs or ports — the
placement preview shows the difference before you save.
Central Certificate Store bindings
Bindings with the CCS flag (sslFlags bit 2) load their certificate from a file
share, not the machine certificate store — a store-thumbprint bind cannot update
them. Every placement except single reports such bindings as skipped_ccs and
marks the run partial so they are visible rather than silently wrong.
For very large machines, the per-binding result list stored on the distribution is
capped at 200 entries (binding_results_truncated: true is set); the scalar
counters (bindings_updated, bindings_failed, bindings_name_mismatch,
sites_updated, …) remain authoritative. Consider raising the target's command
timeout when thousands of bindings match. With Restart App Pool on, a selection that
can span several sites recycles only the pools of the sites whose bindings were
actually updated.
Binding name check
With Verify Binding Names (verify_binding_names) on, a deploy refuses to bind
this certificate to a binding it does not serve, instead of binding it and leaving
browsers to report a name error. It is opt-in (off by default); a distribution
can force it on or off for its certificate (overrides). With it off,
nothing is compared and the deploy behaves as before.
Only a binding whose certificate would change is checked — a binding already
carrying this certificate is not re-judged, and in the multi-binding modes Central Certificate
Store bindings are skipped before the check. The certificate's names are its DNS SANs (its Common Name
only when it has no DNS SAN); IP SANs are not names. Names compare case-insensitively,
without a trailing dot, and internationalised labels the way Windows maps them (the same
IdnMapping the host applies — straße compares as strasse, and a name typed with combining accents as its composed form — then
in punycode form), so the check agrees with what the binding actually serves.
| Binding | Accepted when |
|---|---|
| Has a host header | A certificate name covers it: an exact match, or a one-label wildcard — *.hb.com covers www.hb.com, but never hb.com itself and never a.b.hb.com. Partial-label wildcards (f*.hb.com) never match. An IIS wildcard host header *.hb.com is covered only by the literal name *.hb.com. |
| No host header | The certificate currently on the binding (looked up by thumbprint in the binding's own store) shares at least one name with the new one. Nothing bound, that certificate not found in the store, or a certificate with no names = nothing to compare, accepted. Names the old certificate served that the new one does not are reported as the warning IIS_BINDING_NAMES_DROPPED — the deploy still succeeds. |
What a refusal does depends on the apply mode:
| Mode | Refused binding |
|---|---|
single | The target fails with IIS_NAME_MISMATCH (not retried). The check runs before the certificate is imported, so nothing is imported or bound. |
Filtered selection (and all_matching, explicit_list, all_sites) | The binding is skipped (name_mismatch in the per-binding result, with the reason) and the others are updated; the target is partial (reason binding_name_mismatch — unless a missing or failed binding already set binding_not_found / binding_update_partial) with the warning IIS_NAME_MISMATCH_SKIPPED. If every candidate is refused (CCS bindings aside), the target fails with IIS_NAME_MISMATCH. The certificate is imported only before the first binding actually bound, so a run that binds nothing leaves the store untouched. |
With the check on and a certificate that carries no DNS name at all, the target fails
with IIS_NAME_MISMATCH before any remote call. A refusal writes nothing, so it does
not trigger auto-rollback of the other targets.
Dry Run applies the same rules, and so does the
placement preview in a distribution's override drawer (it knows
the certificate); the preview in the target form has no certificate and cannot.
Per-distribution binding overrides
One IIS target (the WinRM connection) can serve many certificates. When
linking a certificate to a distribution, open the certificate's
Distributions → Overrides drawer and set the IIS binding placement for that
certificate (a * default row applies to targets without a specific entry). The
drawer offers the same two ways as the target form:
- Filtered selection (
apply_mode: "selector"on the override) — the selection fields: sites (one, a list, or every site with exclusions),binding_ips,binding_ports,host_headers,include_catch_all,excluded_bindings,expect_single. Every binding filter comes from the override — an empty list there means any, never "keep the target's". The sites are the one thing inherited: leave them empty and the override applies to the target's own site scope — its one site, its list, or every site (a target saved in the earlierall_sitesmode included, with its excluded sites). A selection row with no sites and no filters at all is valid and means every HTTPS binding on the target's sites. - Single binding (exact) —
site_name(optional),binding_ip,binding_port,host_header: exactly one existing binding.
Rows saved before the selection existed keep their meaning until they are
edited: without apply_mode the mode is derived from which fields are filled.
The drawer opens a single-binding row as Single binding (exact), and a port or
host-header row as a Filtered selection, which it saves back with
apply_mode: "selector" — see Earlier modes for the one difference
that makes for a host-header list.
Override fields (no apply_mode) | Effective mode | What gets updated |
|---|---|---|
host_header / binding_port / binding_ip (+ optional site_name) | single | Exactly one existing HTTPS binding |
binding_ports list (+ optional excluded_bindings, site_name) | all_matching | Every existing HTTPS binding on the site at the listed ports |
host_headers list (+ optional single binding_port, site_name) | explicit_list | Exactly the listed host headers at one port |
In that legacy form binding_ports and host_headers are mutually exclusive
(422), and the selection-only fields are refused (422) — they need
apply_mode: "selector". A legacy row that leaves site_name empty inherits the
target's one site, so a per-target row of that shape is refused (422) when the
target covers every site or a list of sites; a selection row has no such limit.
The Default (all targets) row and the group rows are not bound to one target, so a site-less legacy
row that lands on such a target is caught at deploy instead — that target fails
with IIS_SITE_NOT_FOUND (Dry Run reports the same).
Choosing every site in an override is a project operator action, like the rest of the override drawer, and overrides do not pass the configuration-changes approval. To have an administrator review such a change, have an organization owner gate Distribution actions in the project's approval policy (Settings → Approvals). Keep different certificates' selections disjoint — overlapping ones re-bind each other's bindings on every renewal.
A node older than 1.5.54 does not know the selection fields. A target saved as a filtered selection stops there with "no site to deploy to" — a selection naming one site stores it as a one-entry site list precisely so an older node cannot sweep it. An override in the selection form on a target that is still in an earlier mode is read only in part (its site list, every-site choice and IP list are ignored) or as empty, in which case the target's own placement is deployed for that certificate. On a multi-node installation, upgrade every node before saving a filtered selection; before going back to an older release, re-save such targets and overrides in an earlier mode.
- The HTTPS binding must already exist on the site — deploys update
bindings, they never create them (
IIS_BINDING_NOT_FOUNDotherwise; Dry Run catches it first). host_headeris tri-state: omitted = any binding on the site, an explicit empty value (the "Pin the catch-all binding" checkbox, or""via the API) = only the no-host-header binding, a hostname = exact match.- An override replaces the placement as soon as any placement field is
filled — or it says
apply_mode: "selector", which on its own means every binding on the target's sites. An entirely empty entry is rejected (omit the override to keep the target's placement). - Overrides carry placement, with one exception: Verify binding names
(
verify_binding_names) — Follow target (unset), On or Off — forces the binding name check for this certificate. It is resolved on its own: this certificate's row, else its group's row, else the Default (all targets) row, else the target. It is not placement: a row that sets only this flag is accepted and leaves the placement to the group row, the Default row or the target (precedence). - Every other behavior stays on the target: app pool recycling, certificate
store,
remove_old_cert_after_bind, timeouts. - Don't point two certificates at the same binding (or overlapping selections): an IIS binding holds exactly one certificate, so each renewal would flip it back and forth.
- Certificates coexist in the Windows store under distinct thumbprints, each with its own per-certificate remote state; concurrent deploys to the same host are serialized by a per-device lock (shared with the WinRM and Exchange modules, so cross-module deploys to one box serialize too).
- Trust model: setting overrides is a project operator action, like creating the target itself — but a target change goes through the configuration-changes approval (all operators by default), an override does not — so it deliberately delegates per-certificate placement on reviewed targets, and every change is audited with the actor and full payload.
Choosing from the server (live pickers)
Both the IIS target form and the per-distribution override drawer can read the server and offer what is actually there instead of asking you to type names from memory:
- Sites — every site, with its state, application pool and how many HTTPS bindings it has (a site with none cannot serve a certificate).
- Bindings — the site's HTTPS bindings, each labelled with the
certificate it carries right now (subject and expiry) so you can see at a
glance whether picking it would displace an unrelated certificate. The
binding IP, port and host-header pickers are all views over this one
listing. For a filtered selection over several sites or all sites
(or an override inheriting such a target) they list the bindings of every
site the selection covers — the listed sites, or all sites minus the
excluded ones — not just one site's.
In single-binding mode the three pickers narrow each other to bindings
that exist: pick a host header and the port list shows only the ports it is
bound on; pick a port and the host list shows only that port's host headers
(a port with only the catch-all binding lists none — pin the catch-all
instead). When the fields do not name exactly one binding, a warning under
them says so before the preview or a deploy: none — a typed value, or a
placement saved earlier (
IIS_BINDING_NOT_FOUND, with what the site has on that port) — or several, typically no host header on a shared port (IIS_BINDING_AMBIGUOUS). In an override row the warning appears only when the row carries its own placement; without one the group row's, the Default row's or the target's placement applies. It uses the listing a picker already loaded, so it shows once one of the pickers has been opened. - Application pools — for the recycle field.
The lists are read-only (Get- cmdlets only), fetched over the target's normal
WinRM connection, and rate-limited to 60 requests per minute per project. Large
machines are capped at 500 entries per listing. Nothing is read until you open
a list — opening a form never touches your servers, so a drawer covering ten
targets does not dial ten machines.
Which bindings would this touch?
Next to the placement fields — in the target form and in each certificate's per-target override row (not the Default row or a group row, which span several machines) — Preview affected bindings asks the server to resolve the placement you have typed and lists exactly what a deploy would update, with the certificate currently on each binding. It needs no saved distribution, and it changes nothing.
It exists because the two ways a placement goes wrong are invisible while typing:
- Too wide. A site name with no host header or port matches every HTTPS
binding on the site. In single-binding mode a deploy then fails with
IIS_BINDING_AMBIGUOUS— the preview lists the bindings it caught and says so, instead of stopping at the first one. - Too narrow, or a typo. Nothing matches (
IIS_BINDING_NOT_FOUND), or a listed host header exists nowhere in the selected sites — which downgrades a real run topartial. Both are flagged before you save.
Rows are labelled will be updated, excluded (host header in
excluded_bindings), central store — skipped (a Central Certificate Store
binding the deploy skips) or no such binding. The matching is the same the
deploy uses, so the list is the real blast radius rather than an estimate. The
preview runs only when you ask for it; once open it re-runs shortly after you
stop editing, never on every keystroke.
In a certificate's override drawer the preview also knows the certificate, and judges each selected binding the way Dry Run does, with the same words:
already current — no change— the binding already carries this certificate (Dry Run:already-current).not served by this certificate— with Verify Binding Names on (the row's own setting, else its group row's, else the Default row's, else the target's), a binding the deploy would refuse; hover it for the reason (Dry Run:name-mismatch). A binding without a host header that passes shows, on hover, the names its current certificate serves that this one does not.
In the target form there is no certificate — a target serves many — so every
selected binding reads will be updated and the name check is not applied.
The drawer's preview follows your unsaved edits, while Dry Run and Run use the saved overrides; the drawer says "Unsaved changes" while the two differ. Save, then Dry Run, to compare like with like.
Two rules to know:
- Typing always works. Every picker has a manual-entry toggle, and it falls back to a plain input when the server can't be reached, so an unreachable host never blocks the form. When a listing fails, the server's own reason is shown (for example that the site does not exist) rather than a generic error.
- Who may browse. Listing through a saved target is a project operator action (same level as setting overrides). Browsing from a target form that hasn't been saved yet sends the connection details you just typed and is therefore restricted to project admins — a saved target has been through the configuration-changes approval, an unsaved one has not. The same rule covers the credential: a saved target is browsed with the credential it was saved with; pairing it with a different credential (changing the dropdown on an existing target before saving) also needs project admin, because that pairing is exactly what the approval reviewed. In the override drawer the "Default (all targets)" row and the group rows have no single server behind them, so their fields stay manual-entry.
Dry Run
Dry Run connects but changes nothing. It lists a per-binding plan — one entry per matched binding showing the site, the binding, and the action:
update— the binding would be (re)bound to the new certificate.already-current— the binding already serves this certificate.skipped_ccs— a Central Certificate Store binding that the deploy will skip (multi-binding modes only; asingledeploy binds CCS bindings like any other, so its plan never shows this).excluded— a binding whose host header is inexcluded_bindings; skipped.missing— a listed host header no selected binding carries; the deploy reports it and degrades topartial. Over several sites the row reads "no such binding on any selected site".name-mismatch— with Verify Binding Names on, a binding the deploy would change but this certificate does not serve, with the reason. The deploy skips it (multi-binding modes) or refuses the run withIIS_NAME_MISMATCH(single). When the deploy would fail outright —singlemode, or no binding left to bind — the dry run also adds a warning saying so.
With the name check on, an update binding without a host header also lists the names
its current certificate serves that the new one would drop (IIS_BINDING_NAMES_DROPPED),
and a certificate with no DNS name fails the dry run with IIS_NAME_MISMATCH.
The plan selects bindings exactly as the deploy does: single applies the
host-header filter and the "more than one binding" check; every other placement — a
filtered selection and the earlier all_matching / explicit_list / all_sites
modes — runs the deploy's own matcher, so it lists the same bindings the deploy
would bind (with expect_single, more than one fails the dry run with
IIS_BINDING_AMBIGUOUS). A placement that can span several sites (every site, or a
site list) also shows a summary line (sites in scope, matched_sites,
matched_bindings, ccs_skipped, excluded_bindings, name_mismatch when the name
check is on, and per-site counts for the first 50 sites). The per-binding list stops
at 500 rows, and a final truncated row says how many more exist (the counters count
all of them). Always Dry Run before the first execute to confirm the scope.
A failed pre-flight is shown as one line — the code and its message, for example
IIS_BINDING_AMBIGUOUS: Multiple matching HTTPS bindings — not PowerShell's full
error record.
Timing. Different hosts are checked side by side (up to 8 at a time; targets on
the same host one after another), and the whole dry run is bounded at 100 seconds.
Each target's own budget (Target Timeout, else 2 × the command timeout + 15 s) is
shortened to what is left, so a slow host is reported on its own row while every
other target still returns its plan. The error names the bound that fired and the step
it cut off — IIS_CONNECT: the pre-flight did not finish within the <n>s this target had (cut off during “run pre-flight”), or IIS_CONNECT: “run pre-flight” did not finish within the command timeout (<n>s) when a single round trip hit Command Timeout. Each target shows how long it took; hover the time to see its round
trips (upload pre-flight script, run pre-flight — the binding discovery rides in
the same run). A slow upload or run on one host points at that host — endpoint
protection scanning C:\Windows\Temp, a cold PowerShell, WinRM quotas.
The current thumbprint is read from each binding's own certificateHash, which IIS
exposes per binding — SNI bindings included. So a binding that already carries the
new certificate is reported already-current in Dry Run whatever its SNI flag, a
multi-binding sweep of an unchanged certificate updates nothing and reports
Changed = false, and Remove old cert after bind finds the previous certificate
of an SNI binding. (Verified on Windows Server 2025 / IIS 10, where certificateHash
is the hex thumbprint string; a host returning raw bytes is converted the same way.)
Execution flow
Targets on different hosts deploy in parallel — up to Parallel Windows Hosts at once (Settings → General,
distribution_windows_max_concurrency, default 8). Targets on the same host always run one after another, so two
sites on one server never race on its IIS configuration. Each target has its own deploy budget
(target_timeout_seconds, else five times the command timeout plus 30 s — 330 s by default); a target the job had no
time left to start is reported cancelled. Per host:
- Already bound? When this target's recorded state says an earlier run already bound this very certificate (a retry after a later step timed out, or a re-run of the same version), one read-only check asks whether every selected binding already carries it and the certificate is in the store. If so, the uploads and the import+bind are skipped and the run goes straight to the app-pool recycle and cleanup; any doubt runs the normal deploy.
- Backend builds a PKCS#12 bundle from cert + key + chain, password-wrapped with an ephemeral passphrase.
- Uploads the PKCS#12 to a temp file under
C:\Windows\Temp, created as a new file readable only by the executing user, SYSTEM and Administrators (nothing inherited from the folder). A leftover staging file CertAutoPilot cannot remove is refused rather than written into, and a host that refuses the restricted create gets the file restricted withicaclsin the same step — if that fails too, the file is deleted and the transfer fails withIIS_HOST_PREREQ. The bundle travels on the remote command's standard input rather than its command line, so the key material never reaches Windows process-creation auditing, and the target verifies the content it received before the file is put in place. Each upload is bounded by the target's command timeout, like every other remote command. - Uploads the bundle's password as its own file (same transfer, same restricted ACL) — it never appears in a script or an error message.
- Selects the binding(s). With Verify Binding Names on, each binding whose certificate would change is name-checked first. Then imports with
Import-PfxCertificateinto the configured store (skipped when the store already holds the thumbprint; in the multi-binding modes only once a binding is actually going to be bound), then replaces the HTTPS binding's SSL cert on the IIS site ((Get-WebBinding).AddSslCertificate) — one binding insinglemode, each selected binding independently in the multi-binding modes, where a binding that already carries the thumbprint is left untouched. The certificate in the store gets the friendly nameCAP-<certificate name>(the name it has in CertAutoPilot, or its primary domain when it has none), so it is easy to find in the IIS binding dialog andcertlm.msc; a certificate already in the store is renamed the same way (any friendly name it had is replaced). A run that finds the binding already serving this exact certificate stops before this step, so renaming a certificate in CertAutoPilot shows on the server with its next deployed version. A failure to set the name is logged and does not fail the deploy. singlemode only: a second script validates that the thumbprint is in the store and that the binding (and the site/port'sIIS:\SslBindingsentries) carry it. A failed validation fails the target withIIS_VALIDATE_STORE/IIS_VALIDATE_BINDING; the result still reports whether the bind changed the binding, so auto-rollback can act on it.- Optionally recycles the site's app pool(s). A recycle makes the post-deploy validation wait 30 seconds and retry more patiently before it judges the binding.
- Optionally removes the previously bound certificate from the store (Remove old cert after bind) — only when the binding actually changed and no other IIS SSL binding still references it; not during a rollback.
- Deletes the temp files (the script's own
finally, and again from the backend regardless of how the run ended), then emits the result (per-binding in multi-binding modes).
By default old certificates stay in the store untouched — deleting them blindly can break other applications on the same host. Enable Remove old cert after bind to have the module delete the previously bound certificate after a successful bind, but only when no other IIS SSL binding on the machine still references it. Anything older than that (or referenced elsewhere) still needs an occasional manual sweep (e.g. Get-ChildItem Cert:\LocalMachine\WebHosting | Where NotAfter -lt (Get-Date)).
Retries & partial results
A step that runs out of time says which step and how long it ran: for example "“import and bind” did not finish
within the command timeout (60s) — it ran 1m0s (raise command_timeout_seconds, or find out why the host is slow)", or
that the target's deploy budget ran out during it (raise target_timeout_seconds), followed by the round-trip times
of the steps before it.
Failures are classified so fan-out can auto-retry the
transient ones: a dropped/timed-out WinRM connection (IIS_CONNECT) or a failed
PFX transfer is retried; a genuine binding/validation error (IIS_BINDING_NOT_FOUND,
IIS_VALIDATE_BINDING, …) is not — re-running can't fix it, and neither is a refusal
by the host (IIS_AUTH, HTTP 401/403): a rejected credential cannot succeed on a second
attempt and every retry adds a failed-logon record. Not retried either: an HTTP 200 that is
not a WinRM reply (IIS_CONNECT — another web server or a proxy on the port) and a script that
printed more than 64 MiB, stopped on the host (WINRM_OUTPUT_LIMIT). An untrusted or mismatched WinRM
listener certificate is IIS_AUTH too, and not retried: only a change to the trust,
the address or tls_skip_verify fixes it. The bind is idempotent
(a cert already in the store is not re-imported; in the multi-binding modes a binding
already carrying the thumbprint is left alone, and in single mode the bind call is
repeated but binding the same certificate again changes nothing — the result then
reports Changed = false), so a retry after a partial network failure is safe. Full
class table: Distribution error codes.
A multi-binding run reports partial when some bindings succeed and others are
skipped or fail — binding_update_partial when bindings failed or CCS bindings were
skipped, binding_not_found when some requested host headers had no binding,
binding_name_mismatch when the binding name check skipped bindings this
certificate does not serve. IIS_NAME_MISMATCH is a validation error and is not retried.
Multi-binding and machine-wide placements generate large PowerShell scripts. To stay clear of the
Windows command-line length limit, any script above a small threshold is streamed to
a temporary .ps1 on the target (over the file transport) and run with
-File, then deleted — so machine-wide runs work regardless of how many bindings
match. This is automatic and needs no configuration.
Rollback
Supported via previous-version re-deploy: a rollback re-imports a previous retained certificate version's PFX into the certificate store and repoints the HTTPS bindings at its thumbprint — the module's normal deploy path, fed older material. During a rollback run the remove_old_cert_after_bind behavior is suppressed, so the newer certificate stays in the Windows certificate store and rolling forward again is instant. Eligibility, the version picker, and auto-rollback: Rollback.
Troubleshooting
IIS_AUTH ... HTTP 401 — the host refused the request
The most common failure, and it is almost always authorization — not the transfer itself. The message now carries the facts the host gave: the HTTP status, the auth schemes the listener offered (server offers …), the server's own words when it sent any, and the check list below. (Before 1.5.53 all of these collapsed into 401 - invalid content type, which named neither a cause nor a next step.)
Failures that never reach WinRM — nothing listening on the port, TLS on/off mismatched with the listener, an untrusted listener certificate, DNS, a web site answering on the port — name themselves in the message too; the complete catalogue for all three Windows modules is WinRM troubleshooting.
Read the offered schemes first — they identify the cause. A default WinRM listener offers Basic, Negotiate on plain HTTP. What is missing is the signal (each row below was reproduced on a live Windows Server):
| The message says | What it means | Fix |
|---|---|---|
server offers Basic, Negotiate and the target is NTLM | The credential itself was refused, or the account is not authorized for WinRM | Steps 1–2 below |
server offers Negotiate on plain HTTP | AllowUnencrypted=false — Windows withholds the Basic challenge entirely when it will not accept unencrypted traffic | Step 3 |
HTTP 500 with nothing else, on plain HTTP | AllowUnencrypted=false — some hosts refuse the unencrypted request with an empty 500 instead of the 401 | Step 3 |
server offers Basic only, target is NTLM | Negotiate is disabled on the service, or incoming NTLM is blocked by policy | Step 4 |
server offers Kerberos only | Same as above on a domain-hardened host | Step 4 |
-
Is the account a local Administrator? A valid account that is not one gets the same bare 401 as a wrong password when it is in no WinRM-authorized group, and
HTTP 500 … Access is denied(named as such in the message) when it is only in Remote Management Users. Either way the fix is the Administrators group — the certificate import needs it regardless:net user <user> # Account active? Password expires?net localgroup Administrators | findstr /i <user>net localgroup Administrators <user> /addThe Security log tells the two apart (verified on a live host): a 4625 event means the logon was rejected —
0xC000006Dwrong password,0xC0000064no such user,0xC000015Bthe account may not log on over the network (a "Deny access to this computer from the network" right, common in hardened baselines). No 4625 at all means the logon succeeded and WinRM refused the account's authorization — i.e. it is not an administrator. -
With UAC enabled, is
LocalAccountTokenFilterPolicy = 1set? A local admin over a network logon gets a filtered (non-admin) token without it. This only applies when UAC is on (EnableLUA=1); with UAC disabled the setting has no effect:$p = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System'$p.EnableLUA # 1 = UAC on (then the next value matters)$p.LocalAccountTokenFilterPolicy # should be 1(See Prerequisites for the command to set it.) Not needed for the built-in Administrator or for domain accounts.
-
Plain HTTP (5985) without
AllowUnencrypted? The client does not encrypt the WSMan body, so over HTTP the service must haveAllowUnencrypted="true"— for NTLM, Basic and Kerberos alike. The tell is in the message: the listener still offersNegotiatebut noBasicchallenge. Basic additionally needsBasic="true"and a bare username (user, not.\user):winrm get winrm/config/service/auth # Basic = true ?winrm get winrm/config/service # AllowUnencrypted = true ?winrm set winrm/config/service/auth '@{Basic="true"}'winrm set winrm/config/service '@{AllowUnencrypted="true"}'Restart-Service WinRMPrefer HTTPS 5986 in production; nothing above is needed there.
Earlier releases suggested switching to Basic when only the PFX transfer failed, on the theory that NTLM could not carry a large WinRM body. Re-tested on a live Windows Server against the current transport (which streams the payload on the remote process's stdin): 64 KiB, 1 MiB and 4 MiB transfers all succeed over NTLM. If only the transfer fails while small commands succeed, look at the host — a disk-full C:\Windows\Temp, an AV/EDR hook, or a WinRM quota — not at the auth type.
-
NTLM disabled on a hardened / domain-joined box. When the message says the listener offers no
Negotiate, NTLM can never succeed there. Two causes:Negotiate="false"on the service, or incoming NTLM blocked by policy. Check what it offers — on the boxwinrm get winrm/config/service/auth(Negotiatemust betrue), or from anywhere a raw POST returns the accepted methods:curl -s -i -X POST http://<host>:5985/wsman \-H "Content-Type: application/soap+xml;charset=UTF-8" --data x | grep -i WWW-AuthenticateIf it lists only
Negotiate+Kerberosand NTLM keeps failing, incoming NTLM is blocked by Network security: Restrict NTLM: Incoming NTLM traffic (commonly enforced by a domain GPO). Three options:# (a) Allow incoming NTLM. On a domain box this is usually GPO-controlled — set it in the# domain GPO or it reverts on the next gpupdate/reboot. Local override for a quick test:New-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0' `-Name RestrictReceivingNTLMTraffic -Value 0 -PropertyType DWORD -Force # 0=Allow allRestart-Service WinRM(b) Switch the IIS TARGET to Kerberos. Set Auth Type = kerberos on the target togetherwith the Realm (uppercase AD domain, e.g. CORP.LOCAL); the credential keeps itsbare username, and address the target by its AD FQDN — Kerberos does notauthenticate against a bare IP. Nothing needs to be installed on the CertAutoPilothost: the Kerberos configuration is built in memory and the domain controller isdiscovered automatically via the AD DNS SRV record (or pinned with the optionalKDC Address field when this host's DNS cannot resolve AD records). This matchesexactly what a hardened GPO baseline leaves enabled (Negotiate/Kerberos = true).(c) Or set the TARGET's Auth Type to Basic over HTTPS (port 5986). This only works if BasicCAN be enabled — check `winrm get winrm/config/service/auth`:`Basic = false [Source="GPO"]` means Basic is also policy-locked and cannot beturned on from the box.An unrecognized
auth_typeon an IIS target is rejected when the target is saved; one left in a legacy credential fails the connection withinvalid auth_type— neither falls back to NTLM silently.
Confirm what the server sees: on the target, the Security event log records the WinRM logon. A successful logon is event 4624 (Logon Type 3, NTLM V2) — if you see 4624 (not 4625) but the deploy still fails, authentication works and the problem is authorization (steps 1–2), not the password.
"Failed to connect to WinRM"
Check winrm quickconfig on the target, confirm the listener exists (winrm enumerate winrm/config/listener), and verify the firewall allows the port. From the backend host: Test-NetConnection <host> -Port 5985 (or 5986). If the target field points at the IIS site port (443/80) instead of the WinRM port (5985/5986), you also get a 401 with an HTML body — put the WinRM port in Port, and the site port in Binding Port.
Port 5986 open, but the TLS handshake resets
If a connection to 5986 is accepted and then reset during the TLS handshake (connection reset / abrupt close before any HTTP response), the WinRM HTTPS listener has no usable server certificate bound — the port answers because the listener exists, but Windows aborts the handshake when it cannot present a certificate (missing, expired, or its private key inaccessible). Fix it on the target:
winrm enumerate winrm/config/listener # HTTPS listener present? CertificateThumbprint set and valid?
# Bind a server-auth certificate (from your internal CA; CN/SAN must match the hostname CAP dials):
New-Item -Path WSMan:\localhost\Listener -Transport HTTPS -Address * -CertificateThumbprint <thumbprint> -Force
Restart-Service WinRM
The backend must trust the certificate's chain, or the target must set TLS Skip Verify (not recommended for production). Until the listener is fixed, the target can run over HTTP 5985 with NTLM.
IIS_MODULE_MISSING
The WebAdministration PowerShell module isn't on the target. Install it: Install-WindowsFeature Web-Scripting-Tools (IIS Management Scripts and Tools). The target's health check reports this before any deployment does.
IIS_HOST_PREREQ — the host cannot run the deployment
The host answered, the credential was accepted, but something about the host stops the scripts from running. At deploy time that is PowerShell locked to Constrained Language, or a transfer larger than the host's WinRM message-size limit (Windows answers HTTP 413; the health check only warns about a low limit — a certificate upload usually fits), or a staging file in C:\Windows\Temp that cannot be created restricted to the connecting account — a leftover .captmp CertAutoPilot cannot remove, or icacls failed on a host that refused the restricted create (the file is removed, nothing is imported). The health check reports more under this code before any deploy: a non-administrator or UAC-filtered account, an unwritable C:\Windows\Temp, a PowerShell older than 3, an inaccessible certificate store. The message names which one and the command that fixes it. Not retried — a retry repeats the same refusal. Full catalogue: WinRM troubleshooting.
"Access is denied" during Import-PfxCertificate (IIS_AUTH)
The account lacks permission to write to the LocalMachine cert store — it is not a local Administrator, or LocalAccountTokenFilterPolicy is unset so its admin token is filtered. See step 1–2 above. The target fails with IIS_AUTH. A different message, "Access to the path 'C:\Windows\Temp\…' is denied", is a filesystem permission problem on the staged temp file and is reported as IIS_IMPORT_FAILED — check the temp directory's ACLs, not the account.
A bind exception (IIS_BINDING_FAILED)
In single mode an exception from AddSslCertificate (for example when HTTP.sys refuses the certificate) fails the target with IIS_BINDING_FAILED and the exception's own message; the certificate is already in the store. In the multi-binding modes the failing binding is recorded individually and the run is partial (or IIS_BINDING_FAILED when no binding could be updated).
IIS_BINDING_NOT_FOUND — no binding matched
No HTTPS binding on the selected site(s) matched the requested IPs/ports (or host headers) — or, with expect_single, none was left after the host-header filter. The run fails with IIS_BINDING_NOT_FOUND — it is never a silent no-op. The module never creates bindings, so the binding must already exist.
The message says what to fix, in one line, and Deploy, Dry Run and Preview affected bindings say the same thing:
- what the placement asked for (
ip=* port=443 host=www.example.com, or the selection's sites, IPs, ports and host headers); - the binding(s) a previous deploy of this certificate updated that are no longer on the site — the binding was changed or removed in IIS (its host header, port or IP edited, switched to http, or deleted);
- the site's HTTPS bindings as they are now (at most 15 listed).
For example, after the host header www.example.com was edited to shop.example.com in IIS Manager:
IIS_BINDING_NOT_FOUND: no HTTPS binding on site 'Shop' matches ip=* port=443 host=www.example.com - the binding(s) a previous deploy updated are no longer there, changed or removed in IIS: *:443:www.example.com - HTTPS bindings on the site now: *:443:shop.example.com
Update the target (or the distribution override) to the binding that now exists, or put the binding back in IIS. The "no longer there" part needs a previous deploy of the certificate to this target; without one only the request and the current bindings are named. The Preview shows the error instead of an empty list.
IIS_SITE_NOT_FOUND — site does not exist, or no site at all
Either a named site does not exist on the server (check Get-IISSite; pick
it from the site picker instead of typing it — for a site list the
message names every missing site, and nothing is bound), or the resolved
placement has no site: a legacy per-certificate override that leaves the site
empty inherits the target's one site, and a target covering every site or a site
list has none to inherit.
Per-target overrides of that shape are refused when linking; the Default (all
targets) row and the group rows are not bound to one target, so they fail at deploy (and Dry Run)
with this code instead.
A site in excluded_sites of an every site placement that does not exist is
not this error: it is skipped with the warning IIS_EXCLUDED_SITE_NOT_FOUND
(Dry Run lists it too) — unless it was renamed (below). The target's health check
reports a missing site as a warning (the target stays healthy: every
distribution may override the target's own site); only a renamed site makes it
unhealthy.
IIS_SITE_RENAMED — the site was renamed in IIS
A site the placement names (or an excluded site, when its new name is a site the
placement would bind) is no longer on the server under that name, but the site a
previous deploy recorded under it is — with a new name. A deploy records each site it
touches: its IIS id, all of its HTTPS bindings (up to 20) and its root folder (the
physical path of the site's root application). CertAutoPilot recognises a rename
by the same id, every recorded binding still on that site, and either a
recorded binding with a host header or the same root folder (compared without
regard to case or a trailing \). IIS gives a new site the lowest free id, so a
site that was deleted and replaced by another one — often with the same catch-all
binding such as *:443: but its own folder — is not mistaken for a rename (that
case is IIS_SITE_NOT_FOUND). A site that lost a recorded binding also reads as
IIS_SITE_NOT_FOUND. The message names the new name, for example:
IIS_SITE_RENAMED: site 'Shop' appears to have been renamed to 'Shop (old)' in IIS (site id 4) - update the target
Nothing is imported or bound, and the other targets of the run are not rolled
back. Deploy, Dry Run, the health check and the placement preview
all report it. Update the target to the new name — the Update to “…” button
beside the error opens the target with the new name filled in (an ordinary edit,
so it goes through your approval policy) — or, if the name comes from a
distribution's override, change the override. CertAutoPilot never edits the
target by itself. The record lives with the deployments to the target: a site
renamed before any certificate was deployed to it through CertAutoPilot — or
after every certificate that was deployed there has been deleted — has nothing
recorded and reads as IIS_SITE_NOT_FOUND.
IIS_NAME_MISMATCH — the certificate does not serve the binding
Verify Binding Names is on (on the target, or forced by the
distribution's override) and refused the binding: the certificate's names do not
cover its host header, or — for a binding without a host header — share no name with
the certificate currently on it. The message names the site, the binding and the
reason. Nothing was imported or bound, and the error is not retried. In the
multi-binding modes this code means every candidate was refused; a run where only
some were refused is partial instead. It is also raised before any remote call when
the certificate carries no DNS name.
Run Dry Run to see each refused binding (name-mismatch) and why, then fix the
placement (site, port, host header, excluded_bindings) or deploy the right
certificate. Turn the check off for this distribution only if the binding is meant to
change. Remember that *.example.com does not cover example.com.
See also
Warnings
A run can succeed and still carry warnings, shown in the Warnings column of the target result:
| Code | Meaning |
|---|---|
IIS_TEMP_CLEANUP_FAILED | The uploaded PFX/password temp files could not be removed from the host. |
IIS_INSECURE_TRANSPORT | tls_skip_verify is on: the WinRM HTTPS listener certificate was not verified. (Plain HTTP 5985 does not raise it — that case only writes a job-log warning when the auth type is Basic.) |
IIS_LARGE_PFX | The PFX was large enough to risk WSMan quota limits. |
IIS_PARTIAL_POOL_RECYCLE | Some application pools recycled, others failed. |
IIS_ALL_POOL_RECYCLE_FAILED | Every pool recycle failed (the certificate is still bound). |
IIS_IPV6_BINDING_SKIPPED | An IPv6 binding was skipped. |
IIS_OLD_CERT_IN_USE | The previous certificate was left in place because another binding still uses it. |
IIS_OLD_CERT_CLEANUP_FAILED | Removing the previous certificate from the store failed. |
IIS_CCS_BINDING_SKIPPED | A Central Certificate Store binding cannot be updated through the machine store and was skipped. |
IIS_NAME_MISMATCH_SKIPPED | Verify Binding Names skipped one or more bindings this certificate does not serve; the others were updated and the target is partial (reason binding_name_mismatch, unless a missing or failed binding set its own reason first). |
IIS_BINDING_NAMES_DROPPED | With Verify Binding Names on, a binding without a host header was updated, but the certificate previously on it also served names the new one does not cover (listed in the job log). |
IIS_EXCLUDED_SITE_NOT_FOUND | A site in excluded_sites of an every-site placement is not on this server; it was skipped and the run went on (the job log and Dry Run name it). An excluded site renamed to a site the run would bind stops the run with IIS_SITE_RENAMED instead. |
IIS_RESULT_UNREADABLE | A follow-up script (application-pool recycle, old-certificate cleanup) ran and exited cleanly, but its result could not be read — so whether the pools recycled or the old certificate was removed is unknown. The certificate itself is bound; re-run the deployment or check the host. |
Video tutorial
Short, hands-on videos showing this feature working for real. English audio, English and Turkish subtitles. All video tutorials →