Skip to main content

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 with SPIFFE_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 the kubectl.kubernetes.io/default-container annotation gets it, or the pod's first container when there is no annotation. Init containers never get it.
WhatWhereAvailable
Encrypt and decrypt with the deployment's keyPOST /polaris-container/key/encrypt and POST /polaris-container/key/decryptNow, on AWS, GCP, Azure, Oracle and on-prem. Oracle needs proxy v1.1.0-rc.38 or later, the pinned release
A secret by nameGET /polaris-container/secrets/<name>, and a file on the secrets tmpfsPolaris Identity 1.0
Short-lived cloud credentialsGET /polaris-container/identity/cloud-credentialsPolaris Identity 1.0, GCP first
Workload certificate and JWT-SVIDs/run/polaris/workload.sockPolaris 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="}
  • plaintext is standard base64. ciphertext comes 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.
PlatformCustodianThe proxy calls it as
AWSAWS KMSThe workload VM's instance role, while the Policy Manager's grant on the key stands. See AWS
GCPCloud KMSThe 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
AzureKey Vault, RSA keys onlyThe workload VM's managed identity, while the Policy Manager's role assignment on the key stands. See Azure
On-premHashiCorp Vault TransitThe node's own Vault login, from a certificate the Policy Manager issues on each pass. See On-prem
OracleOCI VaultThe 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 GKECloud KMSNot 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​

Polaris Identity 1.0

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.

PlatformWhere the proxy reads <name>
GCPSecret Manager in the deployment's project, secret <name>, version latest
On-premVault 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 set max_versions=1 on the prefix or destroy the old version when you rotate.
  • On a Vault that several deployments share, no deployment's kv_prefix may sit under another's. With team and team/b, the first deployment's workloads read the second's secrets. Deploy warns when kv_prefix is 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, PASSWD or PASSPHRASE, as in DBPASSWORD, unless a word is ALLOW, EMPTY, RANDOM, REQUIRE, REQUIRED, LENGTH or POLICY (ALLOW_EMPTY_PASSWORD is a flag). Or a word ends in SECRET or SECRETS, as in AWS_SECRET_ACCESS_KEY (not SECRETARY_NAME).
  • The last word is TOKEN or TOKENS, unless a word is MAX, MIN, NUM, LIMIT, COUNT, PROMPT, COMPLETION, INPUT, OUTPUT or TOTAL: AUTH_TOKENS is a secret, MAX_TOKENS and PROMPT_TOKENS are not.
  • The last word is PASS, PWD, PW, KEY, KEYS or SK after another word, unless that word is SORT, PRIMARY, PARTITION, FOREIGN, CACHE, ROUTING, LOOKUP, IDEMPOTENCY, HASH, RANGE, MAP, DEDUP, PUBLIC, PUB, KMS or OBJECT: DB_PASS, DB_PW, STRIPE_SK, SIGNING_KEY and PRIVATE_KEY_PEM are secrets, SORT_KEY, PUBLIC_KEY and PWD_DIR are not.
  • The last word is WEBHOOK or WEBHOOKS, or URL or URI after WEBHOOK or HOOK, as in SLACK_WEBHOOK_URL, whose path holds the secret.
  • The last word is PAT, BEARER, AUTH, AUTHORIZATION, HMAC, SALT, MNEMONIC, CREDENTIAL, CREDENTIALS, CREDS, APIKEY, APIKEYS or PRIVATEKEY, as in GITHUB_PAT.
  • The last word is SEED after OTP, TOTP, HOTP or MFA, as in OTP_SEED, or PHRASE after SEED.
  • The key is SERVICE_ACCOUNT followed by a format word, as in SERVICE_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/polaris as the Workload API socket, on the host's /run tmpfs, 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​

Polaris Identity 1.0

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​

Polaris Identity 1.0

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=false the proxy serves no certificate.
  • A one-shot fetch after a fail gets PermissionDenied. A client that streams, such as go-spiffe's X509Source, 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 x5c header, and never outlive it. Validate them through the socket's ValidateJWTSVID, 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's iat may 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:

ClaimValue
isshttps://<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
audsts.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, jtiexp is iat plus 300 seconds
deployment_id, node_id, workloadThe node and workload the token is for. node_id is the full node id
measurementThe node's attested launch measurement
policy_versionThe access policy version in force when the Policy Manager signed
https://aws.amazon.com/tagsSession 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:

CloudWhere the cloud finds the key
AWSA 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
AzureThe 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
OracleAn 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:

PlatformCustodian withdrawal
On-premImmediate when the Policy Manager reaches Vault. At most six minutes when it cannot
AWSAbout 30 seconds while KMS applies the retired grant, and several minutes in some cases
GCPIn 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
AzureAzure 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
OracleOCI 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​

Polaris Identity 1.0

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.