---
title: "Deploy Confidential Container Workloads on Intel TDX Platform (Beta)"
slug: "fortanix-ccm-deploy-confidential-container-workloads-on-intel-tdx-platform"
updated: 2026-08-05T16:02:40Z
published: 2026-08-05T16:02:40Z
canonical: "support.fortanix.com/fortanix-ccm-deploy-confidential-container-workloads-on-intel-tdx-platform"
---

> ## Documentation Index
> Fetch the complete documentation index at: https://support.fortanix.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Deploy Confidential Container Workloads on Intel TDX Platform (Beta)

## 1.0 Introduction

This document describes the steps to set up a machine for the Publisher (Model Owner) to convert container images into Confidential Container-compatible images in **Fortanix Confidential Computing Manager (CCM)** using **Fortanix Trust Domain Extensions (TDX) Converter**, and the steps for the Consumer to build, attest, register, and run applications in **Intel TDX** within a shared workflow.

This document describes the end-to-end procedure for preparing and running Confidential Containers on **Intel Trust Domain Extensions (TDX)**. The procedure involves two roles: the **Model Owner**, who prepares and converts container images into Confidential Container-compatible images, and the **Consumer**, who builds, attests, registers, and runs the resulting applications in a TDX environment.

The Model Owner is responsible for preparing a build machine and converting standard container images into Confidential Container-compatible images using the Fortanix TDX Converter.

The Consumer is responsible for deploying the converted image on a TDX-enabled platform, enrolling the compute node, registering the application, and running the workload.

Together, these steps establish a trust chain from image creation through runtime execution. The Model Owner ensures the image is correctly hardened and confidential-computing-ready, while the Consumer independently verifies (through attestation) that what's running matches what was published.

## 2.0 Definitions

- **Publisher** (Model Owner) - A Publisher is a model owner who securely shares a proprietary model with enterprises without exposing the model artifact, model weights, or configuration details.
- **Consumer** (Enterprise) - A Consumer is an enterprise that runs a proprietary model on-premises without gaining access to the underlying model artifact, model weights, or configuration details.

## 3.0 Enroll the Fortanix Node Agent for Intel TDX

> [!NOTE]
> NOTE
> 
> The node agent enrollment is only performed by the **Consumer**.

The Fortanix Node Agent software enables the registration of compute nodes with Fortanix CCM when installed on a compute node. It verifies the integrity of the underlying hardware and software running on the node and supports application attestation and workload visibility within Fortanix CCM.

*For more information on how to download and enroll a compute node on an* Intel TDX *platform, refer to* [*Enroll a Compute Node Using Bare Metal - Intel TDX*](/v1/docs/enroll-a-compute-node-bare-metal-intel-tdx-1).

## 4.0 Configure Fortanix CCM

> [!NOTE]
> NOTE
> 
> The **Publisher** (Model Owner) and **Consumer** (Enterprise) must create their own Fortanix CCM account and group.

### 4.1 Create an Account

A Fortanix Armor account is the top-level container for Fortanix CCM, builds, and nodes. An account is generally associated with an organization, rather than an individual. Different accounts are fully isolated from each other.

To get started with Fortanix CCM you must first sign up on Fortanix Armor and create an account. If you already have an existing account, log in to that account.

*For more information on how to sign up, log in, and create a Fortanix Armor account, refer to* [*Getting Started with Fortanix Armor*](https://support.fortanix.com/docs/fortanix-armor-getting-started).

### 4.2 Create a Group

In Fortanix CCM, a group is a collection of users and objects that helps users manage identities, create collaborating groups, and organize and secure applications, datasets, and workflows that belong to the group.

1. Create a Fortanix Armor IAM group. *For detailed instructions, refer to* [*Fortanix Armor Identity and Access Management*](https://support.fortanix.com/docs/fortanix-armor-identity-and-access-management-iam#h_01j324m2f9ttzjx2gqwfpvwehs)*.*
2. Copy the **Group Id** from the browser or using the copy icon by navigating to the detailed view of the group. This will be used by the Publisher (Model Owner) when creating a Confidential Container image.

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/fortanix-confidential-computing-manager-create-and-deploy-confidential-container-workloads-on-amd-sev-snp-platform-v1.0-image-c7110z6b.png)

**Figure 1: Create a group**

### 4.3 Download Zone CA Certificate from Your Fortanix CCM Account

> [!NOTE]
> NOTE
> 
> The **Consumer** (Enterprise) is required to download the Zone CA Certificate and securely share it with the **Publisher** (Model Owner) for upload to their Key Management System (KMS) to enable Secure Key Release (SKR) functionality. The SKR feature ensures that cryptographic keys are released from Fortanix DSM only when the application proves it is running in a trusted and secure environment, thereby protecting both the data and model.
> 
> The method used to share the certificate is outside the scope of this guide.

Perform the following steps to download the Zone CA Certificate from your Fortanix CCM user interface (UI):

1. In the CCM UI left navigation panel, click **Infrastructure → COMPUTE NODES → Intel TDX**, and then click **ADD NODE**.
2. On the **Enroll Compute Node** dialog box, click **DOWNLOAD ZONE CA**. The downloaded certificate will be uploaded by the Publisher (Model Owner) to Fortanix DSM in [*Section 5.0: Configure Fortanix DSM*](/v1/docs/fortanix-confidential-computing-manager-create-deploy-confidential-container-1#50-configure-fortanix-dsm).

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/fortanix-confidential-computing-manager-create-and-deploy-confidential-container-workloads-on-amd-sev-snp-platform-v1.0-image-rpc8hgzs.png)

**Figure 2: Download zone CA**

## 5.0 Configure Fortanix DSM

> [!NOTE]
> NOTE
> 
> The **Publisher** (Model Owner) is required to create an account, group, applications and security objects in Fortanix DSM.

### 5.1 Create an Account and a Group

A Fortanix DSM account is the top-level container for security objects managed by Fortanix DSM. An account is generally associated with an organization, rather than an individual. Security objects, groups, and applications belong to exactly one account. Different accounts are fully isolated from each other.

To get started with Fortanix DSM you must first sign up in and create an account. If you already have an existing account, log in to that account.

- *For more information on how to* ***sign up and log in to Fortanix DSM account****, refer to* [*Sign Up for Fortanix Data Security Manager SaaS*](https://support.fortanix.com/docs/users-guide-sign-up-for-fortanix-data-security-manager-saas).
- *For more information on* ***setting up an account and creating a group****, refer to* [*Getting Started with Fortanix Data Security Manager – UI*](https://support.fortanix.com/docs/users-guide-getting-started-with-fortanix-data-security-manager-ui)*.*

### 5.2 Create an Application (app) with Trusted CA Authentication

Create an application to authenticate to Fortanix DSM using a Transport Layer Security (TLS) client certificate signed by a Trusted Certificate Authority (CA). This app will be used for decrypting the model and weights when the Confidential Container launches.

1. Click the **Groups** menu item from the DSM left navigation panel and select the group you created in [*Section 5.1: Create an Account and a Group*](/v1/docs/fortanix-confidential-computing-manager-create-deploy-confidential-container-1#51-create-an-account-and-a-group) to go to its detailed view.
2. Click **APPS→ ADD APP** to create a new application.

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/fortanix-confidential-computing-manager-create-and-deploy-confidential-container-workloads-on-amd-sev-snp-platform-v1.0-image-shyhzgij.png)

**Figure 3: Create an app**
3. Follow the steps [*here*](/v1/docs/sequoia-pgp-1) to configure a new app with the following details:

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/fortanix-confidential-computing-manager-create-and-deploy-confidential-container-workloads-on-amd-sev-snp-platform-v1.0-image-d86l2k5o.png)

**Figure 4: App with Trusted CA authentication**
  1. **Interface**: REST API
  2. **Authentication Method**: Trusted CA
  3. **DNS Name**: my-server
  4. **Upload Trusted CA Cert**: Upload the Zone CA Certificate downloaded and shared by Consumer (Enterprise) in [*Section 4.3: Download Zone CA Certificate from your Fortanix CCM Account*](/v1/docs/fortanix-confidential-computing-manager-create-deploy-confidential-container-1#43-download-zone-ca-certificate-from-your-fortanix-ccm-account).
4. Click **SAVE**.

### 5.3 Create an app with API Key Authentication

Create an application to authenticate to Fortanix DSM using API key. This API key is a random, secret token that identifies an app in the same way as a password identifies a user. This app will be used for encrypting the model and weights.

1. Repeat *Steps 1-2* from previous [*Section 5.2: Create an Application (app) with Trusted CA Authentication*](/v1/docs/fortanix-confidential-computing-manager-create-deploy-confidential-container-1#52-create-an-application-app-with-trusted-ca-authentication).
2. Follow the steps [*here*](/v1/docs/sequoia-pgp-1) to configure a new app with the following details:

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/fortanix-confidential-computing-manager-create-and-deploy-confidential-container-workloads-on-amd-sev-snp-platform-v1.0-image-8tnhgn12.png)

**Figure 5: App with API Key authentication**
  1. **Interface**: REST API
  2. **Authentication Method**: API Key
3. Click **SAVE**.

### 5.4 Create Security Objects (Optional)

Security objects (keys) can be created from the Fortanix DSM user interface (UI) or programmatically. An option using sq-dsm is described in [*Section 7.0: Encrypt and Decrypt Model Using SQ-DSM*](/v1/docs/fortanix-confidential-computing-manager-create-deploy-confidential-container-1#70-encrypt-and-decrypt-the-model-using-sqdsm).

## 6.0 Prepare the Build Machine

Prepare a Linux build environment that will be used to generate the Confidential Container image.

Perform the following steps:

1. To provision a Linux build machine, use a supported Linux distribution with sufficient disk space and privileges to convert the Confidential Container image.
2. Install the build tools and utilities required by your image-conversion workflow. This typically includes packages such as docker, tar, and other standard Linux utilities.

## 7.0 Encrypt and Decrypt the Model using sq-dsm

You can encrypt the model using various methods. The example below demonstrates encryption using Fortanix [*sq-dsm*](https://support.fortanix.com/docs/clients-sequoia-pgp). Model Owners may choose an alternative encryption method based on their requirements.

### 7.1 Configure for Encryption

Configure the Fortanix DSM client and authentication settings required to generate keys and encrypt the model.

1. Download and install the Fortanix sq-dsm library from [*here*](https://fortanix.zendesk.com/hc/en-us/articles/4408325101460-Sequoia-PGP).
2. Set the following environment variables:
  - `FORTANIX_API_ENDPOINT`: Set your Fortanix DSM endpoint (for example, `https://amer.smartkey.io`) when using API key authentication for encryption.
  - `FORTANIX_API_KEY`: API key of the Fortanix DSM application.
  - `FORTANIX_APP_UUID`: App UUID of the Fortanix DSM application configured for the Trusted CA authentication method.

### 7.2 Generate a PGP Key in Fortanix DSM

Create a Fortanix DSM-managed PGP key that will be used to encrypt and decrypt the model.

Run the following command to generate three security objects in DSM: one primary key and two subkeys.

```bash
sq-dsm key generate \
  --dsm-key "model-enc-key-1" \
  --cipher-suite "rsa4k" \
  --userid "modelowner@example.com"
```

Where,

- `--dsm-key`: The name of the key to be created in DSM.
- `--cipher-suite`: The cryptographic algorithm for the key.

Default: `cv25519`

Possible values: `rsa2k`, `rsa3k`, `rsa4k`, `rsa8k`, `cv25519`, `nistp256`, `nistp384`, `nistp521`
- `--userid`: The user ID attached to the key for reference.

### 7.3 Extract the Certificate (Public Key)

Export the public certificate associated with the Fortanix DSM key for use during model encryption.

Run the following command to export the public key for encryption:

```bash
sq-dsm key extract-cert \
  --dsm-key "model-enc-key-1" \
  --output model.cert.pgp
```

Where,

- `--dsm-key`: The name of the key in DSM.
- `--output`: The file name where the extracted certificate is stored.

### 7.4 Encrypt the Model

Run the following command to encrypt the model file using the exported public certificate:

```bash
sq-dsm encrypt \
  --recipient-cert model.cert.pgp \
  --compression none \
  FILE_TO_BE_ENCRYPTED \
  -o NAME_OF_ENCRYPTED_FILE
```

Where,

- `--recipient-cert`: The certificate file used for encryption.
- `FILE_TO_BE_ENCRYPTED`: Name of the model file to encrypt.
- `NAME_OF_ENCRYPTED_FILE`: The output file name for the encrypted model.

### 7.5 Configure for Decryption

Configure certificate-based authentication to enable secure model decryption at runtime.

Perform the following steps:

1. Install the Fortanix sq-dsm library from [*here*](https://fortanix.zendesk.com/hc/en-us/articles/4408325101460-Sequoia-PGP).
2. Set the following environment variables:
  - `FORTANIX_API_ENDPOINT`: Set your Fortanix DSM endpoint (for example, https://amer.smartkey.io) when using Trusted CA authentication for decryption.
  - `FORTANIX_APP_UUID`: App UUID of the Fortanix DSM application configured for the Trusted CA authentication method.
  - `FORTANIX_PKCS12_ID`: The PKCS#12 identity file used for certificate-based authentication.
3. Run the following command to generate the PKCS#12 identity file:

```bash
openssl pkcs12 -export \ 
-out identity.pfx \ 
  -inkey /opt/fortanix/attestation-client/key.pem \ 
-in /opt/fortanix/attestation-client/cert.pem
```
4. Run the following command to set the environment variable:

```bash
export FORTANIX_PKCS12_ID=identity.pfx
```

### 7.6 Decrypt the Model (Runtime)

Run the following command to decrypt the encrypted model file at runtime using the corresponding Fortanix DSM key:

```bash
sq-dsm decrypt \
  --dsm-key "model-enc-key-1" \
  NAME_OF_ENCRYPTED_FILE \
  -o NAME_OF_DECRYPTED_FILE
```

Where,

- `--dsm-key`: Name of the Fortanix DSM key used during encryption.
- `NAME_OF_ENCRYPTED_FILE`: The encrypted model file.
- `NAME_OF_ENCRYPTED_FILE`: The output file name for the decrypted model.

### 7.7 Troubleshooting

If you see the following error:

```bash
Multiple auth methods found. Using API key
Error: Decryption failed
Caused by: Unauthorized access
```

Unset the `FORTANIX_API_KEY` environment variable before performing decryption:

```bash
unset FORTANIX_API_KEY
```

## 8.0 Containerize the Model

Containerize the application together with the encrypted model file. The application must use CCM-issued attestation certificates to authenticate with DSM and decrypt the model at runtime inside the Container.

When building the container image, ensure the following are correctly integrated:

- The encrypted model is included in the container image.
- The application is configured to use CCM-issued certificates for DSM authentication.
- Model decryption logic is executed at startup using sq-dsm or an equivalent mechanism.

## 9.0 Download the Fortanix TDX Converter

Run the following command to download the Fortanix TDX Converter Docker image:

```plaintext
docker login cr.download.fortanix.com -u username -p password
docker pull cr.download.fortanix.com/tdx-converter:latest_version
docker tag cr.download.fortanix.com/tdx-converter:latest_version tdx-converter:latest_version
```

> [!NOTE]
> NOTE
> 
> - Replace `latest_version` with the latest supported Fortanix TDX Converter image version. *Refer to the* [*release notes*](https://fortanix.zendesk.com/hc/en-us/sections/51659807134356-Fortanix-TDX-Converter-Release-Notes) *for the appropriate image version for your releas*e.
> - Contact Fortanix Support to obtain the container registry credentials and the latest supported converter image version.

## 10.0 Convert the Container Image

Use the Fortanix TDX Converter to convert a standard Docker image into an EnclaveOS container image that can run as a Confidential Container. The converter generates the image measurement required to register the application build in Fortanix CCM.

### 10.1 Create the Converter Request

The Fortanix Intel TDX Converter creates EnclaveOs container images using a request file. Create a converter request file named `converter-request.json`.

```bash
{
  "input_image": {
    "name": "nginx:latest",
    "auth_config": {
      "username": "user",
      "password": "password"
    }
  },
  "output_image": {
    "name": "nginx:tdx",
    "auth_config": {
      "username": "user",
      "password": "password"
    },
    "converter_options": {
      "push_converted_image": false,
    }
  },
  "tdx_enclaves_options": {
    "cpu_count": 2,
    "mem_size": "4096M",
    "enable_gpu_passthrough": true
  }
}
```

Where,

- `input_image.name`: The name and tag of the container image to convert. For example, `nginx:latest`.
- `output_image.name`: The name and tag to assign to the converted EnclaveOS container image. For example, `nginx:tdx`.
- `auth_config`: The container registry credentials used to pull the input image or push the converted image, if authentication is required
- `CPU_COUNT`: The number of vCPUs allocated to the converted Confidential Container.
- `MEM_SIZE`: The memory allocated to the converted Confidential Container.
- `push_converted_image`: Set to `true` to automatically push the converted image to the configured container registry.
- `enable_gpu_passthrough`: Set to `true` to enable GPU passthrough for GPU-enabled workloads.
- Application certificates are provisioned automatically by Fortanix CCM and are available at the following default locations:

Custom certificate paths are not supported. *For more examples, refer to* [*Fortanix Converter File Examples*](https://github.com/fortanix/salmiac/blob/beta/api-model/examples).
  - Private key: `/opt/fortanix/enclave-os/default_cert/app_private.pem`
  - Public certificate: `/opt/fortanix/enclave-os/default_cert/app_public.pem`

*To learn more about Converter environment variables, refer to* [*Fortanix GitHub Documentation*](https://github.com/fortanix/salmiac/blob/beta/ENV_VARS.md#container-converter-variables).

### 10.2 Run the Converter

Run the following command to convert the input image using the image converter. Pass the above `converter-request.json` using `--request-file`.

```bash
docker run \
  --rm \
  -e RUST_LOG=debug \
  -e ENCLAVEOS_DEBUG=debug \
  --privileged \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e PRESERVE_IMAGES=input,result \
  -v "converter-request.json:/app/req.json" \
  tdx-converter:latest_version \
  --request-file "/app/req.json"
```

When launched, the converter pulls the `input_image` (using the optional `auth_config`) and after the conversion completes, creates the EnclaveOs container image specified in `output_image` (using the optional `auth_config`). If `push_converted_image` is set to `true`, the converted image is pushed to the configured container registry.

### 10.3 Verify the Conversion

Sample output of the conversion response would look like below:

```bash
{ 
    "name": "nginx-tdx", 
    "sha": "f79d704ba77de15e9e0795928d9e88834a133d9f96ed977c780d6c9808ae2f6a", 
    "size": 519146336, 
    "config": { 
        "measurements": { 
            "mrtd": "7610ddef489f661ba79e83eba7241d4172d8029c43d51850baf7bf22d7589c3a8d5b193dca66f9a3be0660cc376807f6", 
            "rtmr0": "2dfa6f68853be6005126b3f032019292ed810fa321eef5dbbaed995659e361da41086720f5c0e77cdf3cccfd35f41014", 
            "rtmr1": "db01cbc1122c9b4de9dc1e9a5b26be552de064c7fad864dad0678c5905260373d970250a55379968c02d0091974177ea", 
            "rtmr2": "7746d7dc15e5f0029ec54e452aae6aeae6850c56c3c97ac5693de600ed4c622b5007f55066855d5ac195e321f659c6f8", 
            "rtmr3": "62849662019ba6b3e231928c8b3e676c694abdb12b4b2a608d8bc1b14c220afe543a9285639b5d6751f2c0e3186d1bae" 
        } 
    } 
}
```

Note the image measurements, which include `mrtd` and `rtmr0`, `rtmr1`, `rtmr2`, and `rtmr3`. These values are required when creating the Intel TDX application build in Fortanix CCM.

*For more information about request, response models, refer to* [*Fortanix GitHub Documentation*](https://github.com/fortanix/salmiac/blob/beta/api-model/docs/models.openapi.yaml)*.*

## 11.0 Register the Converted Application in Fortanix CCM

Use the image measurements generated in [*Section 10.3: Verify the Conversion*](/v1/docs/fortanix-confidential-computing-manager-create-deploy-confidential-container-1#103) to create the Intel TDX application build in Fortanix CCM.

> [!NOTE]
> NOTE
> 
> The **Publisher** and **Consumer** must configure collaborating groups and create the shared workflow in Fortanix CCM before the converted application can be securely shared and deployed.

In Fortanix CCM collaborating groups enable organizations to securely share selected resources and collaborate on common workflows.

*For more information on how to create collaborating groups in Fortanix CCM for* Intel TDX *and run the workflow application, refer to* [*Collaborating Groups and Shared Workflow - Intel TDX Applications*](/v1/docs/collaborating-groups-and-shared-workflows-intel-tdx-1)*.*