> **Experimental**
>
> `@aws-cdk/aws-mediapackagev2-alpha` is an [**experimental**](/stability) (alpha) package: its API may change in any release, without a major version bump.
# CmafEncryptionMethod

Encryption methods for CMAF container type.

- Stability: [Experimental](/cdk/api/stability.html)
- Source: [`lib/endpoint.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/@aws-cdk/aws-mediapackagev2-alpha/lib/endpoint.ts#L792)

## Example

TypeScript:

```ts
declare const channel: Channel;
declare const spekeRole: iam.IRole;
declare const certificate: certificatemanager.ICertificate;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf({
    encryption: CmafEncryption.speke({
      method: CmafEncryptionMethod.CBCS,
      drmSystems: [CmafDrmSystem.FAIRPLAY],
      resourceId: 'my-content-id',
      url: 'https://example.com/speke',
      role: spekeRole,
      certificate,
    }),
  }),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});
```

Python:

```python
# channel: Channel
# speke_role: iam.IRole
# certificate: certificatemanager.ICertificate

OriginEndpoint(self, "Endpoint",
    channel=channel,
    segment=Segment.cmaf(
        encryption=CmafEncryption.speke(
            method=CmafEncryptionMethod.CBCS,
            drm_systems=[CmafDrmSystem.FAIRPLAY],
            resource_id="my-content-id",
            url="https://example.com/speke",
            role=speke_role,
            certificate=certificate
        )
    ),
    manifests=[Manifest.hls(manifest_name="index")]
)
```

Java:

```java
Channel channel;
IRole spekeRole;
ICertificate certificate;

OriginEndpoint.Builder.create(this, "Endpoint")
        .channel(channel)
        .segment(Segment.cmaf(CmafSegmentProps.builder()
                .encryption(CmafEncryption.speke(CmafSpekeEncryptionProps.builder()
                        .method(CmafEncryptionMethod.CBCS)
                        .drmSystems(List.of(CmafDrmSystem.FAIRPLAY))
                        .resourceId("my-content-id")
                        .url("https://example.com/speke")
                        .role(spekeRole)
                        .certificate(certificate)
                        .build()))
                .build()))
        .manifests(List.of(Manifest.hls(HlsManifestConfiguration.builder().manifestName("index").build())))
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.AWS.MediaPackageV2.Alpha
Channel channel;
IRole spekeRole;
ICertificate certificate;

new OriginEndpoint(this, "Endpoint", new OriginEndpointProps {
    Channel = channel,
    Segment = Segment.Cmaf(new CmafSegmentProps {
        Encryption = CmafEncryption.Speke(new CmafSpekeEncryptionProps {
            Method = CmafEncryptionMethod.CBCS,
            DrmSystems = new [] { CmafDrmSystem.FAIRPLAY },
            ResourceId = "my-content-id",
            Url = "https://example.com/speke",
            Role = spekeRole,
            Certificate = certificate
        })
    }),
    Manifests = new [] { Manifest.Hls(new HlsManifestConfiguration { ManifestName = "index" }) }
});
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awsmediapackagev2alpha/v2
var channel Channel
var spekeRole IRole
var certificate ICertificate

awsmediapackagev2alpha.NewOriginEndpoint(this, jsii.String("Endpoint"), &OriginEndpointProps{
	Channel: Channel,
	Segment: awsmediapackagev2alpha.Segment_Cmaf(&CmafSegmentProps{
		Encryption: awsmediapackagev2alpha.CmafEncryption_Speke(&CmafSpekeEncryptionProps{
			Method: awsmediapackagev2alpha.CmafEncryptionMethod_CBCS,
			DrmSystems: []CmafDrmSystem{
				awsmediapackagev2alpha.CmafDrmSystem_FAIRPLAY,
			},
			ResourceId: jsii.String("my-content-id"),
			Url: jsii.String("https://example.com/speke"),
			Role: spekeRole,
			Certificate: *Certificate,
		}),
	}),
	Manifests: []Manifest{
		awsmediapackagev2alpha.Manifest_Hls(&HlsManifestConfiguration{
			ManifestName: jsii.String("index"),
		}),
	},
})
```

## Members

| Member | Description |
| --- | --- |
| `CENC` | Common Encryption Scheme (CENC) - compatible with PlayReady, Widevine, and Irdeto DRM systems. |
| `CBCS` | Common Encryption Scheme with CBCS mode - compatible with PlayReady, Widevine, and FairPlay DRM systems. |

## Referenced by

- [`CmafSpekeEncryptionProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.CmafSpekeEncryptionProps).method
