For years the answer to "can I put my ACM certificate on this EC2 box?" was no. ACM certificates lived on load balancers, CloudFront and API Gateway, and the private key never left AWS. If you needed a public certificate on nginx, you ran certbot, bought one from a commercial CA, or imported something into ACM and handled renewal yourself.
That changed in June 2025, when ACM started issuing public certificates you're allowed to export. AWS renews them for you, but it doesn't install the renewed certificate anywhere. That gap is easy to miss in a design review. It's also how a production endpoint goes down 45 days after the console said everything was fine.
What actually changed
Export is a flag you set when you request an ACM public certificate. If you set it, you can later pull the certificate, chain and private key out of ACM and install them on EC2 instances, containers, on-prem hosts or appliances. The ACM exportable certificate docs cover the flow. Only certificates requested with the flag qualify. Everything you requested before, and everything you request without it, stays inside AWS.
On February 18, 2026, AWS cut the default validity of ACM public certificates from 395 days to 198, to meet the CA/Browser Forum's 200-day maximum that took effect in March. For the new certificates, renewal starts 45 days before expiry. Older 395-day certificates still renew at the 60-day mark and come back as 198-day certificates. The same announcement cut exportable pricing from $15 to $7 per fully qualified domain name and from $149 to $79 per wildcard.
In July 2026, ACM also added a managed ACME endpoint that issues 45-day certificates to standard clients like certbot, cert-manager and acme.sh. That matters when we get to cost.
Where renewal stops
For integrated services, ACM renewal has always done two jobs: issue the new certificate and deploy it. ACM renews the object it holds (same ARN, new serial, new expiry), and AWS pushes it to the ALB or CloudFront distribution. Exported copies only get the first job. The docs mention this exactly once, in a single line under limitations: you must manage the deployment process for exported certificates.
So after renewal, the console shows an expiry date about 198 days out and a renewal status of Success. Meanwhile every nginx, HAProxy, Envoy or F5 that got a copy is still serving the old serial, with 45 days left.
ACM's own expiry alerting won't save you here. The "ACM Certificate Approaching Expiration" and "ACM Certificate Expired" EventBridge events are about the certificate ACM holds, and after a successful renewal that certificate is nowhere near expiring. The copy on your hosts can run all the way to its notAfter date without ACM sending a single event, because as far as ACM can tell, nothing is wrong.
Wiring the redeploy
The trigger is the "ACM Certificate Available" event, which ACM publishes on issuance, renewal and import. Its detail includes an Action field, which you filter on RENEWAL, and an Exported flag. With those, an EventBridge rule can pick out renewals of certificates you've actually exported and send them to a Lambda function, a Step Functions workflow, an SSM Run Command document, or a webhook into your deploy pipeline. The fields are listed in the event reference.
From there, the pipeline has to:
- Call ExportCertificate with a passphrase. ACM returns the certificate, the chain, and a PKCS#8 private key encrypted with that passphrase. The passphrase must be ASCII and can't contain #, $ or %, because of course it can't.
- Get the key into a form each server accepts. nginx can read an encrypted key if you give it a password file, and Envoy takes a password alongside the key. HAProxy wants an unencrypted PEM bundle, so in practice the key gets decrypted somewhere, either in the pipeline or on the host.
- Ship the certificate, chain and key to every host that holds a copy. That means knowing which hosts those are, and ACM doesn't track it. The Exported flag tells you a certificate has left AWS, not where it went. Record the targets somewhere a script can read them, like tags on the certificate or your config management.
- Reload: an nginx reload, an HAProxy reload or runtime API call, SDS if your Envoy setup uses it, or the vendor API for appliances.
- Verify that the serial the listener actually serves matches the serial ACM holds.
Don't rely on the event alone. EventBridge sends it once. If the on-prem box was down for patching, or the autoscaling group replaced an instance from an AMI with last quarter's certificate baked in, the event has already fired and nobody is going to send it again. Run the same pipeline on a schedule to reconcile. The event is just the fast path.
What it costs
Exportable certificates are billed per name, at issuance and again at every renewal. At current list price, that's $7 per FQDN and $79 per wildcard. A certificate covering example.com, www.example.com and *.api.example.com costs $93 every time ACM renews it.
How often that happens depends on the validity period minus the renewal lead time:
| Validity | Renewal starts | Replaced roughly every | Billable issuances per year |
|---|---|---|---|
| 395 days | 60 days before expiry | 335 days | ~1.1 |
| 198 days | 45 days before expiry | 153 days | ~2.4 |
| 100 days | ~30 days (assumed) | ~70 days | ~5.2 |
| 47 days | ~15 days (assumed) | ~32 days | ~11.4 |
AWS hasn't published lead times for 100-day or 47-day certificates, so those two rows are my estimates. Here's the cost per name per year at today's prices:
| Validity | Per FQDN per year | Per wildcard per year |
|---|---|---|
| 198 days | ~$17 | ~$188 |
| 100 days | ~$37 | ~$412 |
| 47 days | ~$80 | ~$901 |
The February price cut didn't make anything cheaper per year. At 395 days and $15 per issuance, an FQDN cost about $16 a year. At 198 days and $7, it's about $17. A wildcard went from about $162 to $188. AWS roughly halved the price per issuance, then made you pay it more than twice as often, so you come out a little behind.
Now scale it to a fleet. Say you have 40 services, each with a three-name certificate, plus five wildcards: 120 FQDNs and 5 wildcards. That's about $2,950 a year at 198 days, $6,400 at 100 days, and $14,100 at 47 days if list prices hold. AWS cut prices once when lifetimes halved and might do it again. I wouldn't budget on it.
The same 125 names through the alternatives:
- Let's Encrypt charges nothing. You pay in setup and upkeep instead: an ACME client on every host, DNS-01 or HTTP-01 validation that actually works, and rate limits to stay under. Let's Encrypt itself moves to 64-day certificates in February 2027 and 45-day in February 2028, so you'll be rotating often either way.
- ACM's ACME endpoint charges $1 per FQDN and $5 per wildcard per issuance for the first 1,000 FQDNs and 500 wildcards a month. Its 45-day certificates rotate roughly monthly, which comes to about $1,740 a year for this fleet. AWS's own pricing example puts 50 FQDNs rotating monthly at $600 a year, or $12 per name. That's already cheaper per name than an exportable certificate at 198 days.
Exportable certificates lose this one. The ACME endpoint issues about five times as often, still costs less per name, and its client deploys the certificate for you, which is the whole problem this post is about.
Failure modes and key custody
The validation record disappears
Managed renewal only works while the DNS validation CNAME still exists. Someone cleans up "unused" Route 53 records, or a zone moves to another DNS provider without the CNAMEs, or a Terraform refactor drops the resource. Renewal stalls. A CAA record that doesn't authorize Amazon's CA does the same thing. ACM reports it with the "ACM Certificate Renewal Action Required" event, with a reason like PENDING_DOMAIN_VALIDATION or CAA_ERROR. More attempts follow at 15, 3 and 1 days before expiry, each with its own event. Send that event to a pager, not to an inbox nobody reads.
The private key has left AWS
The best security property of a non-exportable ACM certificate is that nobody, including you, can get the key. Exporting gives that up. The key now sits on disks and in backups. It may end up in AMIs or container images if someone took a shortcut, and in anything your pipeline logs. If a key leaks, ACM lets you revoke the certificate (only exported certificates can be revoked through ACM). Then you request a replacement, pay for it, and redeploy to every host while the clock runs.
acm:ExportCertificate is a secret-read permission
The passphrase is not an access control, because the caller picks it at export time. It protects the key in transit and at rest. Anyone allowed to call ExportCertificate on a certificate can still walk off with its private key. Treat that permission like secretsmanager:GetSecretValue: scope it to specific certificate ARNs and give it only to the deploy role.
Watch for broad grants that include it, such as acm:* in the AWSCertificateManagerFullAccess managed policy, or admin and power-user roles. An SCP that denies ExportCertificate to everything except the deploy role is cheap insurance. CloudTrail records every export call, so alert on exports by principals you don't expect.
This is also a reason not to have each host call ExportCertificate on a timer. It works, and the first 10,000 calls a month are free. But then every host can pull the key straight from ACM. Push from one place instead.
The export flag can't be added later
Whether a certificate is exportable is fixed when you request it. If a certificate was requested without the flag and you now need it on an EC2 box, you have to request a new exportable certificate, validate it, and repoint anything that used the old one. The opposite mistake happens too. Don't mark everything exportable just in case. Every exportable certificate costs money at each renewal and is one more key that can leave AWS.
How to catch drift
The check that matters is simple: does the serial each endpoint serves match the serial ACM holds? ACM shows the current serial in the certificate details, and a TLS handshake against each listener gives you the one being served. If ACM renewed more than a few hours ago and an endpoint still presents the old serial, the deploy failed. You've found out with most of the 45 days left, not at expiry.
A few things I'd insist on:
- Probe from outside the host. A check that reads the certificate file on disk will pass once the file is updated, even if the process was never reloaded. Check what the socket serves.
- Probe each backend, not just the load balancer address. If one of six nginx instances behind an NLB missed the reload, one handshake in six gets the old certificate. A single probe through the load balancer will usually look fine.
- Alert on the served certificate's expiry, whatever ACM says. If the notAfter your hosts present drops below your threshold, page someone.
When exportable ACM is worth it
Exportable certificates make sense when a handful of off-AWS endpoints need a public certificate, you've already standardized on ACM, and the targets can't run an ACME client. Think appliances with an import API, or legacy hosts where you can't install software. A 198-day lifetime means fewer pushes to fragile boxes than a 45-day ACME certificate would need. Most of that advantage goes away when the CA/B schedule cuts maximum validity to 100 days in March 2027 and 47 days in March 2029.
They don't make sense for a fleet of hosts that can run certbot, cert-manager or acme.sh. Use Let's Encrypt or ACM's ACME endpoint there. Internal-only names belong on a private CA. On Kubernetes, cert-manager already handles deployment.
If you do run exportable certificates, watch for ACM's view and your endpoints' view quietly drifting apart. CertPulse catches this by combining its ACM inventory, including the current serial, with its endpoint probes. A certificate ACM calls renewed while a host still serves the old serial shows up as a mismatch, not as a 2am outage. Whatever tooling you use, the checklist is the same:
- an EventBridge rule on renewal
- a scheduled reconcile
- a locked-down export permission
- a pager on Renewal Action Required
- a probe that compares served serials against ACM's
Skip any of them and you're back to trusting a green status in a console that only knows about its own copy.
This is why we built CertPulse
CertPulse connects to your AWS, Azure, and GCP accounts, enumerates every certificate, monitors your external endpoints, and watches Certificate Transparency logs. One dashboard for every cert. Alerts when auto-renewal fails. Alerts when certs approach expiry. Alerts when someone issues a cert for your domain that you didn't request.
If you're looking for complete certificate visibility without maintaining scripts, we can get you there in about 5 minutes.