Preparing Your Workload
Polaris runs your application unchanged. You bring a container, and Polaris wraps it in a confidential, attested environment: TLS, attestation, encryption, and continuous verification all happen around your app, not inside it. This page describes what makes a good fit, so you know what to expect before you deploy.
Most applications already meet these expectations. Where Polaris is opinionated, it is for a reason worth knowing, and each point below explains it.
The shape of a Polaris workload
A good fit is a single web service in a container: it serves HTTP on one port, keeps its state in external systems, takes its configuration from the environment and its keys and secrets from the Polaris proxy, and reaches only the networks it needs. If that describes your app, there is little to change.
Packaging
- One container per deployment. Polaris protects a single workload container in each confidential VM. Bundle everything that container needs into its image.
- Built for linux/amd64. Confidential VMs run on AMD and Intel hardware, so images need an x86-64 build.
- Bring an image or a Dockerfile. Point Polaris at a prebuilt image from your registry, or at a source directory it builds and pushes for you. Either way, the image you deploy is the one that runs.
- Ship changes as new deployments. Polaris records the exact image it deployed and verifies that the running container still matches it, byte for byte. That check is what catches tampering, so releasing a change means deploying a new version rather than overwriting an existing tag in place.
Serving traffic
Your application listens for plain HTTP on one port inside the environment. The Polaris proxy sits in front of it and handles everything security-related: it terminates TLS on the public side, proves the environment to the client through attestation, and forwards verified requests inward. Clients always reach your workload through the proxy over HTTPS, so your app never has to manage certificates or TLS itself. The proxy sets X-Forwarded-Host and X-Forwarded-Proto to what the client used, replacing anything the client sent, so your app can build public URLs from them.
WebSocket traffic is supported. The upgrade passes Cookie, Authorization and Origin through to your app, and the proxy accepts every origin. If your app authenticates a socket by a cookie, check Origin on the upgrade yourself, or a page on another site could open a socket with your user's cookie. Browsers only send cookies marked SameSite=None cross-site, which narrows this but doesn't remove it.
Network access
- Inbound only through the proxy. Your workload does not expose ports of its own. All traffic arrives through the Polaris proxy, which keeps the attested boundary in one place.
- Outbound is closed by default. A confidential workload reaches the Polaris control components and its own cloud's service endpoints out of the box. Anything else, a third-party API or an external database, you allowlist explicitly. This keeps a workload from quietly talking to places it should not, and it is easy to open up the destinations you do need.
- No borrowing the VM's cloud identity. On a confidential VM the workload cannot read the VM's cloud credentials or reach the metadata service. A compromised application then cannot impersonate the VM to reach your keys and get past attestation. Keys, secrets and cloud access reach the workload through the Polaris proxy instead, as Identity, keys and secrets describes. Kubernetes on GKE is the exception: there the pod gets a token for its own Google service account from GKE's metadata server, never the node's.
Configuration
Configuration comes from environment variables, set under workload.env in the deployment config. Use them for flags and settings that are not secret.
Those values are written into the VM's launch configuration: user data on AWS, custom data on Azure, instance metadata on GCP. Anyone who can read the instance through the cloud's API can read them. So a secret never goes into workload.env as a value. It goes there as ciphertext or, from Polaris Identity 1.0, as a reference, both described below.
Identity, keys and secrets
Everything a workload uses to prove who it is, use a key or read a secret comes from the Polaris proxy in its own VM, and only while that node passes attestation. The workload never holds a custodian credential, never talks to Vault or a cloud KMS itself, and never borrows the VM's cloud identity. Kubernetes on GKE is the one exception today, noted below.
Where the workload asks
Two places, both reachable only from inside the deployment:
- HTTP routes under
/polaris-container/on the proxy's internal listener,http://polaris-proxy:3000. The workload routes in the table below are served only to the workload's own network. A request from anywhere else, the VM itself included, gets 403, and they are never served on 443. The proxy has other routes under the same prefix, such as health and readiness, which are not part of this contract and do not carry that restriction. - A unix socket at
/run/polaris/workload.sock, mounted into the workload container. It speaks the SPIFFE Workload API, so any SPIFFE library works without SPIRE. Point one at it withSPIFFE_ENDPOINT_SOCKET=unix:///run/polaris/workload.sock. The proxy mounts the socket's directory writable and serves the socket in it. The workload container mounts the same directory read-only at/run/polaris, and no other container mounts it.- On a VM it is the host's
/run/polaris-workload, 0750 root with group 3742. Only the workload container runs with that group (--group-add 3742), so non-root processes elsewhere on the guest cannot reach the socket. - On Kubernetes it is an emptyDir in the pod. A chart workload mounts it into its
containerName. In a pod the webhook injects, only the container named by thekubectl.kubernetes.io/default-containerannotation gets it, or the pod's first container when there is no annotation. Init containers never get it.
- On a VM it is the host's
| What | Where | Available |
|---|---|---|
| Encrypt and decrypt with the deployment's key | POST /polaris-container/key/encrypt and POST /polaris-container/key/decrypt | Now, on AWS, GCP, Azure, Oracle and on-prem. Oracle needs proxy v1.1.0-rc.38 or later, the pinned release |
| A secret by name | GET /polaris-container/secrets/<name>, and a file on the secrets tmpfs | Polaris Identity 1.0 |
| Short-lived cloud credentials | GET /polaris-container/identity/cloud-credentials | Polaris Identity 1.0, GCP first |
| Workload certificate and JWT-SVIDs | /run/polaris/workload.sock | Polaris Identity 1.0 |
Anything marked Polaris Identity 1.0 is designed and not shipped yet. Do not build on it before that release.
Keys: encrypt and decrypt
This is how a workload protects data with the deployment's attestation-gated key. The routes are the same on every platform, so the workload's code is written once.
curl -s -X POST http://polaris-proxy:3000/polaris-container/key/encrypt \
-H 'Content-Type: application/json' -d '{"plaintext":"aGVsbG8="}'
# {"ciphertext":"..."}
curl -s -X POST http://polaris-proxy:3000/polaris-container/key/decrypt \
-H 'Content-Type: application/json' -d '{"ciphertext":"..."}'
# {"plaintext":"aGVsbG8="}
plaintextis standard base64.ciphertextcomes back as the custodian writes it. Treat it as opaque.- The proxy calls the custodian under the node's own credential, in the table below. It caches nothing, so every call is a fresh request to the custodian.
- 400 means the request was malformed or the custodian could not use the input. 403 means the call did not come from the workload network. 413 means the body is too large. 503 means no key operation right now: the node is not passing, its grant was withdrawn, or the custodian refused or could not be reached. A 503 comes with
Retry-After: 30. At startup it is normal until the first appraisal passes. - The request body is capped at 1 MiB of JSON, which is a little under 768 KiB of plaintext. A decrypt body may run 4 KiB past that, so any ciphertext an encrypt returned decrypts again. For more data, encrypt a data key with these routes and use it for the bulk, keeping in mind what a revoke does not end, below.
| Platform | Custodian | The proxy calls it as |
|---|---|---|
| AWS | AWS KMS | The workload VM's instance role, while the Policy Manager's grant on the key stands. See AWS |
| GCP | Cloud KMS | The workload VM's service account, while the Policy Manager's grant on the key stands. It grants by the key's IAM policy by default, or by a tag, as How the Policy Manager grants the key describes. From Polaris Identity 1.0, a federated identity the Policy Manager signs for each node. See GCP |
| Azure | Key Vault, RSA keys only | The workload VM's managed identity, while the Policy Manager's role assignment on the key stands. See Azure |
| On-prem | HashiCorp Vault Transit | The node's own Vault login, from a certificate the Policy Manager issues on each pass. See On-prem |
| Oracle | OCI Vault | The workload VM's instance principal, while the Policy Manager's tag keeps the VM in the group the key's policy names. See Oracle |
| Kubernetes on GKE | Cloud KMS | Not through the proxy today. The workload calls Cloud KMS itself, as its own Google service account. See Kubernetes |
On AWS the proxy also signs and checks HMACs under the deployment's HMAC key, at /polaris-container/key/mac and /polaris-container/key/verify-mac. The AWS page shows how.
Where deploy does not take secret references yet, keep a secret as ciphertext from these routes, in workload.env or in your own storage, and decrypt it at run time. That is the only Polaris path for secrets on Oracle.
Secrets: references in workload.env
Secret references land in Polaris Identity 1.0. On GCP deploy takes them with workload federation on (attestation.workload_federation: true and cloud.gcp.federation_parent), and the proxy it pins reads them. Secret leases came in proxy v1.1.0-rc.31. A custom polaris.proxy_image must be that release or later. On-prem deploy takes them when cloud.onprem.vault is set: the proxy reads them from Vault KV under the workloads cert role, which the Policy Manager publishes its workload CA to from v1.1.0-rc.49. On-prem runs the images you bake, not a pinned one, so the baked Policy Manager must be v1.1.0-rc.49 or later and the baked proxy v1.1.0-rc.34 or later.
An entry in workload.env can name a secret instead of holding it:
workload:
env:
LOG_LEVEL: info
DATABASE_PASSWORD: polaris://secret/db-password
The secret stays in your own custodian: Vault KV under a workload role, or the cloud's secret manager under the node's federated identity. The Policy Manager decides which node may fetch it and never holds the value.
| Platform | Where the proxy reads <name> |
|---|---|
| GCP | Secret Manager in the deployment's project, secret <name>, version latest |
| On-prem | Vault KV v2, the value field of <kv_mount>/data/<kv_prefix>/<name>, set by cloud.onprem.vault.kv_mount (default secret) and kv_prefix (default polaris-<deployment_id>) |
On-prem, the grant is per deployment, not per workload: every workload on every node of the deployment can read every secret under kv_prefix. Keep secrets that only one workload may see out of it. Two more things to know on Vault:
- KV v2 keeps old versions, and the workload's read reaches them with
?version=N. A rotated secret stays readable until its old versions are destroyed, so setmax_versions=1on the prefix or destroy the old version when you rotate. - On a Vault that several deployments share, no deployment's
kv_prefixmay sit under another's. Withteamandteam/b, the first deployment's workloads read the second's secrets. Deploy warns whenkv_prefixis not the default.
Names are 1 to 255 of A-Z a-z 0-9 _ -, and a value is at most 64 KiB. Write the reference bare, with no quotes inside the value. The value reaches the container as it is, quotes included, so DB_PASSWORD: '"polaris://secret/db"' would give the workload the quoted string and no proxy would read the secret. Deploy, the GCP and Oracle modules and the Azure Marketplace form refuse a reference in quotes. On AWS, Azure and Oracle deploy refuses a reference, since the proxy has no custodian to read it from there yet. attestation_mode: hardware refuses one too, on GCP and on-prem: there is no Policy Manager, so nothing issues the workload certificate and no pass ever fetches it.
Deploy warns about a literal value where a reference or ciphertext is expected, and with workload.strict_secrets: true refuses it. That is a value in a key whose name says it is a secret. The key is split into words, camelCase first (githubToken), then on anything that is not a letter or digit, case ignored. A last word of FILE, PATH, DIR, NAME, ID or ARN says the value points at a secret, so the key is fine when the value looks like a pointer: a path (with a /, or starting with . or ~) for FILE, PATH and DIR, an ARN for ARN, anything for NAME and ID. So POSTGRES_PASSWORD_FILE=/etc/app/db-password is fine, and DATABASE_PASSWORD_PATH=hunter2 is checked as DATABASE_PASSWORD. GOOGLE_APPLICATION_CREDENTIALS is fine too. A trailing PEM, JSON, B64, BASE64 or DER is dropped next. The key names a secret when:
- A word contains
PASSWORD,PASSWDorPASSPHRASE, as inDBPASSWORD, unless a word isALLOW,EMPTY,RANDOM,REQUIRE,REQUIRED,LENGTHorPOLICY(ALLOW_EMPTY_PASSWORDis a flag). Or a word ends inSECRETorSECRETS, as inAWS_SECRET_ACCESS_KEY(notSECRETARY_NAME). - The last word is
TOKENorTOKENS, unless a word isMAX,MIN,NUM,LIMIT,COUNT,PROMPT,COMPLETION,INPUT,OUTPUTorTOTAL:AUTH_TOKENSis a secret,MAX_TOKENSandPROMPT_TOKENSare not. - The last word is
PASS,PWD,PW,KEY,KEYSorSKafter another word, unless that word isSORT,PRIMARY,PARTITION,FOREIGN,CACHE,ROUTING,LOOKUP,IDEMPOTENCY,HASH,RANGE,MAP,DEDUP,PUBLIC,PUB,KMSorOBJECT:DB_PASS,DB_PW,STRIPE_SK,SIGNING_KEYandPRIVATE_KEY_PEMare secrets,SORT_KEY,PUBLIC_KEYandPWD_DIRare not. - The last word is
WEBHOOKorWEBHOOKS, orURLorURIafterWEBHOOKorHOOK, as inSLACK_WEBHOOK_URL, whose path holds the secret. - The last word is
PAT,BEARER,AUTH,AUTHORIZATION,HMAC,SALT,MNEMONIC,CREDENTIAL,CREDENTIALS,CREDS,APIKEY,APIKEYSorPRIVATEKEY, as inGITHUB_PAT. - The last word is
SEEDafterOTP,TOTP,HOTPorMFA, as inOTP_SEED, orPHRASEafterSEED. - The key is
SERVICE_ACCOUNTfollowed by a format word, as inSERVICE_ACCOUNT_JSON.
A URL with a password in it, such as postgres://app:pw@db/app, and a connection string with password= or pwd= count too, in ADO.NET, ODBC, libpq (host=db password=pw) and JDBC (?password=pw) form. Empty values, flags (true, false, yes, no, on, off, 0, 1), a path under /run/polaris/secrets/ and ciphertext from the key routes don't. Ciphertext is a key-route prefix followed by at least 28 bytes of base64, so a prefix alone still counts as a literal. The rule runs only in deploy.sh and in the GCP module, so on the GCP Marketplace too, where the form's workload_plain_env and workload_strict_secrets do the same as workload.plain_env and workload.strict_secrets. The Oracle and Azure Marketplace stacks skip deploy.sh and do not check for literals. They refuse a value starting with polaris://: Oracle in the module, Azure in the Marketplace form, so a deployment of Azure's mainTemplate.json without the form is not checked. A Sentry DSN's key is public, and Sentry ships it in browser code, so SENTRY_DSN is not a secret. A key that only looks like a secret, such as SORT_KEY, goes under workload.plain_env and keeps its literal value quietly. A value that starts with polaris:// and is not exactly a well-formed reference is always refused, so a typo never ships as a literal.
On each pass the proxy fetches the value and serves it two ways:
GET /polaris-container/secrets/<name>on the internal listener, the value as the body. 503 when there is no live lease, 404 for a name the deployment does not reference./run/polaris/secrets/<name>, for software that only reads files. It sits in the same read-only/run/polarisas the Workload API socket, on the host's/runtmpfs, so it never reaches a disk.
Read the value from the route or the file, not from the environment: the variable itself still holds the reference. Each value is a lease of two report intervals plus 30 seconds. The proxy fetches it again on each pass and drops it from the route and the directory on a fail, or when five reports in a row do not reach the Policy Manager. An alert renews no lease, so a lease runs out about two report intervals after the last pass. An alert does renew the workload certificate and the federation JWT. The JWT stays in the proxy, but the workload gets the certificate from the socket, which logs in to Vault, and cloud access tokens from the cloud credentials route. So the lapse limits only the proxy's copy: with those the workload can read the custodian itself until they expire. With an enforcement level in alert, as on a new GCP deployment, every report is an alert or a pass, so a workload should expect its secrets to lapse while a deployment is still learning its baseline. Secret references need enforcement on: the proxy refuses them with POLARIS_ENFORCEMENT_ENABLED=false.
Cloud credentials
The cloud credentials route is designed and not shipped yet. It lands in Polaris Identity 1.0, on GCP first.
A workload that needs other cloud APIs gets short-lived, scoped credentials from GET /polaris-container/identity/cloud-credentials. The proxy gets them by trading a JWT the Policy Manager signs for this node at the cloud's token service. The JWT never leaves the proxy, so a leaked workload cannot mint more. The answer is {"provider","access_token","token_type","expires_in","expires_at"}. A direct GCP token lives about 300 s, the JWT's lifetime. With a service account to impersonate it lives the configured lifetime, at most 1 h.
The route answers 503 with Retry-After: 30 when the node has no passing appraisal (before the first pass, after a fail, or once the proxy has failed to reach the Policy Manager for several reports in a row), when the proxy holds no live JWT, or when the token service refuses. Ask again on a 503 rather than caching the failure. A token already handed out still works until it expires. The route needs enforcement on and a report interval of at most 120 s.
Any container on the workload network can fetch the token, not only the workload the JWT names, the same as the key routes. Oracle gets no cloud credentials yet.
Workload identity
The workload certificate, the socket and the federation JWT are designed and not shipped yet. They land in Polaris Identity 1.0.
The proxy makes two keys in memory when it starts. On each pass or alert the Policy Manager signs a certificate for the SVID key and encrypts the federation JWT to the workload key.
- The SVID key. The workload certificate below names it, and the socket serves it to the workload as the certificate's private key.
- The workload key. The federation JWT is encrypted to it on its way from the Policy Manager to the proxy. It never leaves the proxy, so the workload cannot open that JWT even if it got hold of one.
The Policy Manager refuses a request where the two are the same key.
The split ships in Policy Manager v1.1.0-rc.49 and polaris-proxy v1.1.0-rc.34. Upgrade both together. A node with one of them and not the other loses its socket and its Vault secrets:
- A proxy from before the split, with a Policy Manager that has it. The proxy sends one key, and the Policy Manager gives it the federation JWT but no certificate. The socket stops at the first report the new Policy Manager answers, and Vault secrets run out within two report intervals plus 30 seconds of it.
- A proxy with the split, with a Policy Manager from before it. The Policy Manager signs the certificate for the workload key, and the proxy refuses to serve it. From the proxy's start the socket serves nothing and there are no Vault secrets.
Either way it lasts until the node has both releases. Cloud credentials and GCP Secret Manager secrets keep working in both cases, since the federation JWT still reaches the proxy.
A workload certificate, an X.509 SVID from the deployment's workload-ca, valid for two report intervals and at most 15 minutes. When the proxy sends no report interval, it gets the node certificate's lifetime instead. Its URI SAN is:
spiffe://<trust-domain>/deployment/<deployment_id>/node/<node hash>/workload/<name>
The node hash is the same one the federation JWT's sub carries, below. A node id such as gcp:projects/... holds characters a SPIFFE ID path may not, so SPIFFE libraries would refuse it.
Use it for mTLS between workloads, and for Vault cert auth when a workload needs a Vault role of its own. The socket at /run/polaris/workload.sock serves it with the SVID key and the workload-ca bundle, and serves JWT-SVIDs. The certificate is replaced on each pass. On a fail the socket stops serving it, and streaming clients get the update.
- The socket needs the proxy's enforcement gate, which stops it serving when the Policy Manager goes silent. With
POLARIS_ENFORCEMENT_ENABLED=falsethe proxy serves no certificate. - A one-shot fetch after a fail gets
PermissionDenied. A client that streams, such as go-spiffe'sX509Source, keeps the last certificate it got until that certificate expires, at most 15 minutes after the last pass. - JWT-SVIDs are signed by the SVID key, with the certificate in the
x5cheader, and never outlive it. Validate them through the socket'sValidateJWTSVID, which accepts a JWT-SVID from any workload of the deployment. The JWT bundle the socket serves holds only the public half of this workload's SVID key. A peer'siatmay be up to 30 seconds ahead of the validating node's clock. - The workload holds the certificate and the SVID key until the certificate expires, a fail included. Where Vault's cert auth trusts the certificate and the workload's network reaches Vault, a compromised workload can log in to Vault itself, without the proxy, and read whatever that Vault role's policy grants, not only the secrets the proxy fetches for it. Keep that role's policy to what the workload needs.
A federation JWT, RS256, valid for 300 seconds. The proxy keeps it and trades it at the cloud's token service. You see its claims when you write the cloud-side trust conditions, such as a GCP provider's attribute condition or an AWS role's session tags:
| Claim | Value |
|---|---|
iss | https://<jwks-host>/<deployment_id>. On GCP and Oracle, https://polaris.invalid/<deployment_id> |
sub | <deployment_id>/<node hash>/<workload>, the same on every cloud. See below |
aud | sts.amazonaws.com on AWS, api://AzureADTokenExchange on Azure, the workload identity provider's resource name on GCP, polaris:oci:<deployment_id> on Oracle |
iat, exp, jti | exp is iat plus 300 seconds |
deployment_id, node_id, workload | The node and workload the token is for. node_id is the full node id |
measurement | The node's attested launch measurement |
policy_version | The access policy version in force when the Policy Manager signed |
https://aws.amazon.com/tags | Session tags polaris_deployment and polaris_measurement. Only when the deployment targets AWS |
The node hash in sub is the first 16 bytes of SHA-256 over the node id, as RFC 4648 base32 in lower case without padding. It is always 26 characters from a-z2-7. A verifier rebuilds sub from the deployment_id, node_id and workload claims. For example:
b3f7c2a0-5d1e-4f8a-9c3b-2e6d7a1f0b44/<26 characters>/client-workload
The workload name is at most 63 bytes, in the certificate and the JWT, and must name a container the node reports. With a UUID deployment id, sub is then at most 127 bytes, GCP's limit, whatever the node id. A GCP node id alone runs to about 100 bytes, which is why sub carries its hash.
With attestation.workload_federation: true, deploy publishes the key that signs this JWT to the deployment's cloud:
| Cloud | Where the cloud finds the key |
|---|---|
| AWS | A public S3 bucket behind CloudFront, random name, serving only <deployment_id>/.well-known/openid-configuration and <deployment_id>/jwks.json. <jwks-host> is the CloudFront domain. Register iss as an IAM OIDC provider |
| Azure | The same two files from a storage account's static website. <jwks-host> is its web host. Name iss as a federated identity credential's issuer. The Policy Manager's role carries only blob read and write, with a condition that limits its writes to these two files, and the account takes no shared keys |
| Oracle | An Identity Propagation Trust in cloud.oracle.identity_domain_url that holds the Policy Manager's federation certificate. Deploy reads it from the Policy Manager after it starts |
On AWS and Azure the Policy Manager writes both files at start and after each key rotation, and reports federation_host as ok or stale in its status. A host found stale three checks in a row is written again. The key does not rotate until the host serves the next one. An Oracle trust holds one certificate and OCI allows one trust per issuer, so on Oracle the key never rotates on its own: federation_host says manual, and once rotation_due is true, rotate it (POST /api/v1/issuer-keys/rotate with use federation) and run deploy, which moves the trust. Oracle refuses the new key's tokens between the two. Deploy prints iss at the end. The role or identity the JWT is traded for, and what it may do, is your cloud IAM.
Destroy removes the host and prints iss again, also when it fails partway or is a dry run. Note it from a failed destroy: the re-run may no longer be able to read it. Then delete every IAM OIDC provider, role trust policy or federated identity credential that names it. Deploy cannot, since they are in your accounts. On Azure this matters most: a deleted storage account's name can be registered again by anyone, and a credential that still names the issuer would trust whatever the new account serves.
On a fail, with endorsement_missing, or when a node goes silent, the Policy Manager signs neither. Signing nothing is the revoke.
What a revoke ends, and what it does not
When a node fails or goes silent, access ends in two places. The node's proxy stops serving key operations itself as soon as it receives a fail, or once five reports in a row, by default, cannot reach the Policy Manager. The Policy Manager also withdraws the node's access at the custodian, which holds even if that proxy no longer cooperates. Together that ends the next request:
- The next key operation fails with 503.
- The next secret read fails, and the file leaves the tmpfs.
- The certificate and cloud credentials are not renewed.
It does not reach back into the workload's memory:
- A secret the workload already read stays read.
- A data key the workload unwrapped and keeps in memory outlives the revoke, as with envelope encryption on any KMS. So does a plaintext it kept.
- Cloud credentials already handed out work until they expire.
- The workload certificate and the SVID key work until the certificate expires, at most 15 minutes after the last pass, for mTLS, JWT-SVIDs and Vault cert login.
So call per operation when a revoke should end decryption. A secret that must die with a revoke belongs behind the key routes: keep its ciphertext in config and decrypt it each time you use it.
On the node's own proxy a fail takes effect at once. How quickly the custodian stops the node depends on the platform:
| Platform | Custodian withdrawal |
|---|---|
| On-prem | Immediate when the Policy Manager reaches Vault. At most six minutes when it cannot |
| AWS | About 30 seconds while KMS applies the retired grant, and several minutes in some cases |
| GCP | In the default IAM policy mode, about 2 minutes while IAM applies the removed binding, sometimes 7 or more. Tag mode is not measured. See How the Policy Manager grants the key. From Polaris Identity 1.0, new token exchanges end at once, and a token already exchanged ends with its JWT, at most about 300 seconds after the node's last pass, as below |
| Azure | Azure applies the deleted role assignment with a delay that Polaris has not measured. A new assignment takes up to about five minutes, so plan for at least that. A Policy Manager that stops or hangs leaves the assignment in place until it runs again |
| Oracle | OCI fixes the group when it issues the VM's instance principal token. The proxy uses a token for at most a minute, so its calls stop within about a minute of the tag's removal. Anything else on the VM that holds a token issued while the VM was active keeps the key until that token expires, up to 20 minutes |
On GCP, the Policy Manager stays on the key path
This applies once GCP uses per-node federation for the key, in Polaris Identity 1.0.
With per-node federation, the proxy trades the node's federation JWT at Google's Security Token Service for a federated token and calls Cloud KMS with that token. Polaris uses direct federation: the key's IAM policy names the federation pool's principalSet:// for the deployment, and no service account is impersonated.
How long the federated token lasts depends on that flow:
- Direct federation, which Polaris uses. Google's Security Token Service issues a token "valid for as long as the input token, but at most for 1 hour" (Google Cloud, workload identity federation). The input is the 300 second JWT, so the federated token ends with it, about 300 seconds after the Policy Manager signed it.
- Service account impersonation, which Polaris does not use. A service account access token obtained that way lasts one hour unless a shorter lifetime is asked for.
Google cannot revoke a federated token early. So:
- A revoke ends new exchanges at once, because the Policy Manager stops signing JWTs for the node.
- A fail does not end a token already exchanged. The node's own proxy refuses key operations as soon as it receives the fail. A node whose proxy no longer cooperates can keep using its last token until it expires, at most about 300 seconds after the node's last pass.
- A Policy Manager that is down signs nothing. Every node's proxy closes its key routes after five reports in a row fail to reach it, and once its last token expires no node can get a new one until the Policy Manager is back. So a Policy Manager down for more than about 5 minutes stops key use on every node until it is back. Plan its availability with that in mind.
Ciphertext stays on its platform
Ciphertext decrypts only at the custodian that made it. Vault Transit ciphertext (vault:v1:...) needs that Vault key, and each cloud KMS's ciphertext needs that cloud's key. Polaris does not translate between them.
Moving a deployment to another platform, or to another key, means re-encrypting: decrypt under the old deployment while it still passes, and encrypt under the new one.
State
Treat the workload as stateless. Anything written inside the container is not preserved across a redeploy, so databases, queues, and object storage live outside the confidential VM and your app connects to them over the network. This keeps the protected boundary small and the workload easy to move and rebuild.
Privileges
The workload runs with a minimal set of Linux privileges by default, which is good security hygiene and keeps the attested surface small. If your application genuinely needs a specific capability, you request it in the deployment config, where it becomes a reviewed, explicit part of the deployment rather than a silent default. A read-only filesystem is available as an option and is recommended where your app supports it.
Behaving predictably at runtime
In its deepest attestation mode, Polaris learns what your workload normally does at runtime, its processes, network connections, and file activity, and then flags anything that departs from that baseline. Applications that behave predictably get the most out of this: a service that handles requests without constantly spawning new short-lived processes settles into a clean baseline and can run under the strictest enforcement.
Two things are worth expecting here:
- Fresh deployments start in an advisory state. Right after launch, Polaris is still learning the baseline, so the runtime and image layers report advisory findings rather than enforcing. This is normal and clears once the baseline settles against a healthy, quiet workload.
- Very dynamic workloads take more tuning. Applications that spawn many short-lived processes, run scheduled jobs, or rewrite their own executables are harder for the automatic baseline to pin down, so out of the box they tend to stay advisory. They still run, and still get platform and image attestation from the start. Bringing them under the strictest runtime enforcement is a matter of shaping the baseline to fit how the workload behaves, which we work through with you as part of onboarding.
Resources
Polaris makes sure the attestation components always have the headroom to keep proving the environment, so a workload that spikes in memory or CPU cannot starve them and accidentally take verification offline. You can also set explicit CPU and memory limits for the workload in the deployment config when you want hard caps.
In short
Bring a single, stateless, linux/amd64 web service that serves HTTP on one port, gets its keys and secrets through the Polaris proxy, and reaches only the networks it needs. Polaris handles the rest: confidential execution, attestation, encryption, and continuous verification, with no changes to your code.
Ready to deploy? Continue to Deploying Polaris.