# Contoh bahasa pemrograman backend

DRM-X 6.0 pola integrasi backend untuk PHP, ASP.NET Core, Node.js, Python, Java, Go, dan Ruby menggunakan satu sesi Playback yang aman API.

Cara pemutaran diotorisasi

Backend Anda menentukan siapa yang boleh menonton. DRM-X memberikan otorisasi pemutaran. Pemutar menggunakannya untuk meminta lisensi DRM.

- 01**Penonton**

Masuk ke layanan Anda dan meminta video.

- 02**Backend Anda**

Memeriksa pembelian, langganan, atau izin menonton lainnya milik pengguna.

- 03**DRM-X**

Menerapkan aturan yang dipilih dan mengembalikan konfigurasi serta otorisasi pemutaran.

- 04**Pemutar**

Menggunakan otorisasi yang diterima untuk meminta lisensi DRM yang diperlukan untuk pemutaran.

Backend Anda memutuskan akses; DRM-X memaksa kebijakan yang ditandatangani. Media tersandi dan DRM lisensi mengikuti jalur pengiriman terpisah.

## Permintaan independen [ # ](#the-language-independent-request)

```
POST /api/v1/playback/environments/{siteId}/sessions
X-DRMX-Client-Id: {siteKey}
X-DRMX-Client-Secret: {accessKey}

{
  "contentId": "trusted-content-id",
  "contentType": "vod",
  "drmSystem": "widevine",
  "subject": "authenticated-user-id",
  "sessionId": "new-id-for-this-attempt",
  "licensePolicyTemplate": "multi-tier-standard",
  "useEnvironmentDefaults": true
}
```



## Pilih backend [ # ](#choose-your-backend)

### PHP 8.2 +

Gunakan cURL dengan JSON pengecualian, HTTPS- hanya protokol, timeout 12 detik, dan penanganan respon eksplisit. Aplikasi lengkap PHP termasuk login, hak, direct-token, token-proxy, diagnostik, dan rilis.

[Jalankan PHP contoh](https://developer.drm-x.com/php-sample/)

### ASP.NET Core

Gunakan pilihan yang diberikan validasi, diketik `HttpClient`, pembatalan, `JsonContent`, dan pembantu titik akhir. Nilai konfigurasi jelas dalam kode untuk dijalankan pertama dengan alternatif rahasia-manajer berkomentar.

### Node.js / TypeScript

Gunakan `fetch` dengan `AbortSignal.timeout`, konfigurasi server- only, respon skema validasi, dan `Cache-Control: no-store`.

### Python 3.11 +

Gunakan klien HTTPS dengan waktu eksplisit, JSON serialisasi, pemeriksaan status, dan suntikan rahasia dari waktu-jalan produksi.

### Java 21 +

Gunakan `HttpClient` dengan timeout permintaan, tajuk kredensial tepat, validasi JSON, dan tidak ada redirecting ke asal yang tidak dipercaya.

### Pergi atau Ruby

Gunakan context / timeout permintaan, ruas tepat JSON, pemeriksaan status yang ketat, dan tidak pernah mencetak kredensial atau badan respon pemutaran yang sukses.



## Nilai bisnis peta aman [ # ](#map-business-values-safely)

| Bagian permintaan | Sumber | 
| --- | --- |

| `contentId` | Pemetaan server dari katalog Anda ke berkas yang dilindungi Published. | 

| `subject` | Anda terotentikasi pengguna ID; tidak pernah sebuah browser- memberikan identitas. | 

| `licensePolicyTemplate` | Pemetaan server dari rencana, penyewaan, kursus, atau tingkat isi. | 

| `drmSystem` | Kemampuan klien yang sah, terbatas pada DRM sistem dukungan integrasi Anda. | 

| `sessionId` | Identifier baru tak terduga yang dibuat oleh backend Anda untuk percobaan pemutaran ini. | 



## Gunakan nilai kode langsung hanya untuk run pertama [ # ](#use-direct-code-values-only-for-the-first-run)

Sampel sengaja membuat set kecil pengaturan mudah ditemukan. Untuk produksi, menghapus komentar alternatif lingkungan / rahasia manajer terdokumentasi, menghapus rahasia berkode keras, memutar klien, dan hanya memberikan `license-tokens:create`.



Tutorial server 

## Panggil titik akhir yang sama dari bahasa backend populer [ # ](#call-the-same-endpoint-from-popular-backend-languages)



In every example, authenticate the viewer and check entitlement before this call. PHP and ASP.NET show direct code values for the first run; move the Access Key to a secret manager for production and never log request headers or the successful response body.

PHP 8.2 +



```
$drmx = [
    'platformApi' => 'https://api6.drm-x.com',
    'siteId' => 'your-development-environment-uuid',
    'siteKey' => 'drmx_your_environment_scoped_client_id',
    'accessKey' => 'paste-your-one-time-access-key',
];

$payload = [
    'contentId' => $trustedContentId,
    'contentType' => 'vod',
    'drmSystem' => $drmSystem,
    'subject' => $authenticatedUserId,
    'playbackMode' => 'streaming',
    'licensePolicyTemplate' => 'multi-tier-standard',
    'useEnvironmentDefaults' => true,
    'maximumQualityTier' => 'auto',
];

$curl = curl_init($drmx['platformApi'] . '/api/v1/playback/environments/' .
    rawurlencode($drmx['siteId']) . '/sessions');
curl_setopt_array($curl, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 12,
    CURLOPT_PROTOCOLS => CURLPROTO_HTTPS,
    CURLOPT_HTTPHEADER => [
        'Accept: application/json',
        'Content-Type: application/json',
        'X-DRMX-Client-Id: ' . $drmx['siteKey'],
        'X-DRMX-Client-Secret: ' . $drmx['accessKey'],
    ],
]);
$body = curl_exec($curl);
```



Mulai dari sampel executable lengkap; termasuk login, berhak, mode directtoken, mode token-proxy, diagnosa bunded, dan penanganan rilis.

Node.js / TypeScript



```
const response = await fetch(
  `${process.env.DRMX_PLATFORM_API}/api/v1/playback/environments/${
    encodeURIComponent(process.env.DRMX_PLAYBACK_SITE_ID!)
  }/sessions`,
  {
    method: "POST",
    headers: {
      "Accept": "application/json",
      "Content-Type": "application/json",
      "X-DRMX-Client-Id": process.env.DRMX_PLAYBACK_SITE_KEY!,
      "X-DRMX-Client-Secret": process.env.DRMX_PLAYBACK_ACCESS_KEY!,
    },
    body: JSON.stringify({
      contentId: trustedContentId,
      contentType: "vod",
      drmSystem,
      subject: authenticatedUser.id,
      playbackMode: "streaming",
      licensePolicyTemplate: "multi-tier-standard",
      useEnvironmentDefaults: true,
      maximumQualityTier: "auto",
    }),
    signal: AbortSignal.timeout(12_000),
  },
);
const playback = await response.json();
```

Python 3.11 +



```
import json, os, urllib.request

payload = json.dumps({
    "contentId": trusted_content_id,
    "contentType": "vod",
    "drmSystem": drm_system,
    "subject": authenticated_user_id,
    "playbackMode": "streaming",
    "licensePolicyTemplate": "multi-tier-standard",
    "useEnvironmentDefaults": True,
    "maximumQualityTier": "auto",
}).encode("utf-8")

url = (
    os.environ["DRMX_PLATFORM_API"] +
    "/api/v1/playback/environments/" +
    os.environ["DRMX_PLAYBACK_SITE_ID"] + "/sessions"
)
request = urllib.request.Request(url, data=payload, method="POST", headers={
    "Accept": "application/json",
    "Content-Type": "application/json",
    "X-DRMX-Client-Id": os.environ["DRMX_PLAYBACK_SITE_KEY"],
    "X-DRMX-Client-Secret": os.environ["DRMX_PLAYBACK_ACCESS_KEY"],
})
with urllib.request.urlopen(request, timeout=12) as response:
    playback = json.load(response)
```

ASP.NET Core / C #



```
builder.Services.AddDrmXPlayback(options =>
{
    options.PlatformApi = "https://api6.drm-x.com";
    options.SiteId = "your-development-environment-uuid";
    options.SiteKey = "drmx_your_environment_scoped_client_id";
    options.AccessKey = "paste-your-one-time-access-key";
    options.ApplicationId = "customer-aspnet-website";
    options.LicensePolicyTemplate = "multi-tier-standard";
});

var payload = new {
    contentId = trustedContentId,
    contentType = "vod",
    drmSystem,
    subject = authenticatedUserId,
    playbackMode = "streaming",
    licensePolicyTemplate = "multi-tier-standard",
    useEnvironmentDefaults = true,
    maximumQualityTier = "auto"
};

using var request = new HttpRequestMessage(HttpMethod.Post,
    $"{platformApi}/api/v1/playback/environments/{Uri.EscapeDataString(siteId)}/sessions") {
    Content = JsonContent.Create(payload)
};
request.Headers.Add("X-DRMX-Client-Id", siteKey);
request.Headers.Add("X-DRMX-Client-Secret", accessKey);
using var response = await httpClient.SendAsync(request, cancellationToken);
```

Java 21 / Spring services



```
String payload = objectMapper.writeValueAsString(Map.of(
    "contentId", trustedContentId,
    "contentType", "vod",
    "drmSystem", drmSystem,
    "subject", authenticatedUserId,
    "playbackMode", "streaming",
    "licensePolicyTemplate", "multi-tier-standard",
    "useEnvironmentDefaults", true,
    "maximumQualityTier", "auto"
));

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create(platformApi + "/api/v1/playback/environments/" +
        URLEncoder.encode(siteId, StandardCharsets.UTF_8) + "/sessions"))
    .timeout(Duration.ofSeconds(12))
    .header("Accept", "application/json")
    .header("Content-Type", "application/json")
    .header("X-DRMX-Client-Id", siteKey)
    .header("X-DRMX-Client-Secret", accessKey)
    .POST(HttpRequest.BodyPublishers.ofString(payload))
    .build();
HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());
```

Go 1.23 +



```
payload, _ := json.Marshal(map[string]any{
    "contentId": trustedContentID,
    "contentType": "vod",
    "drmSystem": drmSystem,
    "subject": authenticatedUserID,
    "playbackMode": "streaming",
    "licensePolicyTemplate": "multi-tier-standard",
    "useEnvironmentDefaults": true,
    "maximumQualityTier": "auto",
})

url := platformAPI + "/api/v1/playback/environments/" +
    url.PathEscape(siteID) + "/sessions"
req, _ := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(payload))
req.Header.Set("Accept", "application/json")
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-DRMX-Client-Id", siteKey)
req.Header.Set("X-DRMX-Client-Secret", accessKey)
response, err := httpClient.Do(req)
```

Ruby 3.3 +



```
uri = URI("#{ENV.fetch('DRMX_PLATFORM_API')}/api/v1/playback/environments/" \
          "#{ERB::Util.url_encode(ENV.fetch('DRMX_PLAYBACK_SITE_ID'))}/sessions")
request = Net::HTTP::Post.new(uri)
request['Accept'] = 'application/json'
request['Content-Type'] = 'application/json'
request['X-DRMX-Client-Id'] = ENV.fetch('DRMX_PLAYBACK_SITE_KEY')
request['X-DRMX-Client-Secret'] = ENV.fetch('DRMX_PLAYBACK_ACCESS_KEY')
request.body = JSON.generate(
  contentId: trusted_content_id,
  contentType: 'vod',
  drmSystem: drm_system,
  subject: authenticated_user_id,
  playbackMode: 'streaming',
  licensePolicyTemplate: 'multi-tier-standard',
  useEnvironmentDefaults: true,
  maximumQualityTier: 'auto'
)
response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(request) }
```

<!-- Canonical: https://docs.drm-x.com/id/integrations/backend-languages -->
<!-- Language: id -->