---
title: "Deploy Confidential VM Applications on AMD SEV-SNP Using Fortanix CCM"
slug: "deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm"
updated: 2026-08-19T12:24:25Z
published: 2026-08-19T12:24:25Z
canonical: "support.fortanix.com/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm"
---

> ## 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 VM Applications on AMD SEV-SNP Using Fortanix CCM

## 1.0 Introduction

This article describes the steps to set up a machine for the Publisher (Model Owner) to build a Confidential Virtual Machine (CVM) image, and the steps for the Consumer to build, attest, register, and run applications in **Advanced Micro Devices (AMD) Secure Encrypted Virtualization – Secure Nested Paging (SEV-SNP)** within a shared workflow in **Fortanix Confidential Computing Manager (CCM)**.

## 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 AMD SEV-SNP

> [!NOTE]
> NOTE
> 
> The node agent enrolment 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 AMD SEV-SNP platform, refer to* [*Enroll a Compute Node Using Bare Metal - AMD SEV-SNP*](/v1/docs/enroll-a-compute-node-bare-metal-amd-sev-snp-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*](/v1/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*](/v1/docs/fortanix-armor-identity-and-access-management-iam)*.*
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 CVM image in [*Section 9.0: Create a Confidential VM Image*](/v1/docs/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm#90-create-a-confidential-vm-image).

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/Screenshot (4031)(1).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 → AMD SEV-SNP**, 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/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm#50-configure-fortanix-dsm).

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/Screenshot (4033)(1).png)

**Figure 3: 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 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*](/v1/docs/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*](/v1/docs/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 Virtual Machine (CVM) 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 Group*](/v1/docs/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm#51-create-an-account-and-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/DSM-AddApp.png)

**Figure 4: Create an app**
3. Follow the steps [*here*](/v1/docs/getting-started-with-fortanix-data-security-manager-ui#50-creating-an-application) to configure a new app with the following details:
  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/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm#43-download-zone-ca-certificate-from-your-fortanix-ccm-account).
4. Click **SAVE**.

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/DSM-AddApp1.png)

**Figure 5: App with Trusted CA authentication**

### 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/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm#52-create-an-application-app-with-trusted-ca-authentication).
2. Follow the steps [*here*](/v1/docs/getting-started-with-fortanix-data-security-manager-ui#50-creating-an-application) to configure a new app with the following details
  1. **Interface**: REST API
  2. **Authentication Method**: API Key
3. Click **SAVE**.

![](https://cdn.us.document360.io/c3bd85d2-4ad8-4d85-9f60-f1c168a3aad9/Images/Documentation/DSM-AddApp2.png)

**Figure 6: App with API key authentication**

### 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 the Model Using SQ-DSM*](/v1/docs/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm#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 CVM image.

Perform the following steps:

1. To provision a Linux build machine, use a supported Linux distribution with sufficient disk space and privileges to build the CVM image.
2. Install the build tools and utilities required by your image-building workflow. This typically includes packages such as, `qemu`, `docker`, `tar`, and other standard Linux utilities.
3. Use your organization’s build tooling or automation framework to create the CVM image. The tool must be capable of:
  1. Creating a qcow2 VM image.
  2. Packaging the operating system and application dependencies.
4. Create a working directory where the scripts and output artifacts will be stored.

## 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*](/v1/docs/fortanix-dsm-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*](/v1/docs/sequoia-pgp-1).
2. Set the following environment variables:
  - `FORTANIX_API_ENDPOINT`: Set your Fortanix DSM endpoint (for example, [https://amer.smartkey.io](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*](/v1/docs/sequoia-pgp-1).
2. Set the following environment variables:
  - `FORTANIX_API_ENDPOINT`: Set your Fortanix DSM endpoint (for example, [https://amer.smartkey.io](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 CVM.

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 Create a Confidential VM Image

A Confidential virtual machine (CVM) image must be created to generate the attestation configuration required to register and validate the AMD SEV-SNP application image in Fortanix CCM.

Perform the following steps:

1. Download the [*Fortanix Attestation Client – AMD SEV-SNP*](/v1/docs/amd-sev-snp-attestation-client-linux) provided by Fortanix.
2. Build your CVM image using your preferred build tooling and ensure that the Fortanix Attestation Client is embedded in the CVM image as part of the image build process.

> [!NOTE]
> NOTE
> 
> The Fortanix Attestation Client must be executed before starting the application container. Ensure the execution flow is arranged accordingly.

## 10.0 Calculate Image Measurements

Before copying the CVM image on the Bare Metal VM, perform the following steps to retrieve the image measurements required for attestation.

1. Run the following commands to install the required tools:

```bash
apt install python3.12-venv
source venv/bin/activate
pip install sev-snp-measure
```
2. Run the following command to generate the measurements:

```bash
sev-snp-measure --mode snp --vcpus <no_of_cpus> --vcpu-type <cpu_type> --ovmf <OVMF.fd> --kernel <efi>
```

Record the generated measurement values. These values are required when registering the AMD SEV-SNP application build in Fortanix CCM.

## 11.0 Copy the VM Image into the AMD SEV-SNP Bare Metal VM

The **Publisher** (Model Owner) must securely share the CVM image with the **Consumer** (Enterprise) so that the Consumer can deploy it on their bare metal server. The method used to share this CVM image is outside the scope of this guide

Run the following command to copy the CVM image generated in [*Section 9.0: Create a Confidential VM Image*](/v1/docs/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm#90-create-a-confidential-vm-image) to the target AMD SEV-SNP Bare Metal VM:

```bash
scp <CVM_image_path> <username@remote_host_ip>:</remote/directory/>
```

Where,

- `&lt;CVM_image_path&gt;`: The path where your CVM image is present.
- `&lt;username@remote_host_ip&gt;`: The username and IP of the Bare Metal VM.
- `&lt;/remote/directory/&gt;` : The destination path.

> [!NOTE]
> NOTE
> 
> The **Publisher** (Model Owner) and the **Consumer** (Enterprise) must complete the steps documented in [*Section 12: Create Collaborating Groups and Shared Workflow*](/v1/docs/deploy-confidential-vm-applications-on-amd-sev-snp-using-fortanix-ccm#120-create-collaborating-groups-and-shared-workflow), before the Consumer can deploy the application or model.

## 12.0 Create Collaborating Groups and Shared Workflow

> [!NOTE]
> NOTE
> 
> The **Consumer** must create collaborating groups and shared workflow to collaborate with the **Publisher** and deploy the application or model.

In Fortanix CCM collaborating groups help to securely share selected resources and help users work together on common workflows.

*For more information on how to create collaborating groups in Fortanix CCM for AMD SEV SNP and run the workflow application, refer to* [*Collaborating Groups and Shared Workflow - AMD SEV-SNP Applications*](/v1/docs/fortanix-ccm-collaborating-groups-and-shared-workflows-amd-sev-snp)*.*
