Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Connect vom Service verwaltete Flotten mit einem benutzerdefinierten Lizenzserver
Sie können Ihren eigenen Lizenzserver verwenden, um ihn mit einer vom Service verwalteten Deadline Cloud-Flotte zu verwenden. Um Ihre eigene Lizenz mitzubringen, können Sie einen Lizenzserver mithilfe einer Warteschlangenumgebung in Ihrer Farm konfigurieren. Um Ihren Lizenzserver zu konfigurieren, sollten Sie bereits eine Farm und eine Warteschlange eingerichtet haben.
Wie Sie eine Verbindung zu einem Softwarelizenzserver herstellen, hängt von der Konfiguration Ihrer Flotte und den Anforderungen des Softwareanbieters ab. In der Regel greifen Sie auf zwei Arten auf den Server zu:
+ Direkt zum Lizenzserver. Ihre Mitarbeiter erhalten über das Internet eine Lizenz vom Lizenzserver des Softwareanbieters. Alle Ihre Mitarbeiter müssen in der Lage sein, eine Verbindung zum Server herzustellen.
+ Über einen Lizenz-Proxy. Ihre Mitarbeiter stellen eine Verbindung zu einem Proxyserver in Ihrem lokalen Netzwerk her. Nur der Proxyserver darf über das Internet eine Verbindung zum Lizenzserver des Anbieters herstellen.
Mit den folgenden Anweisungen verwenden Sie Amazon EC2 Systems Manager (SSM), um Ports von einer Worker-Instance an Ihren Lizenzserver oder Ihre Proxy-Instance weiterzuleiten. Wenn Ihr Lizenzserver im folgenden Beispiel keine Lizenz bereitstellen kann, wird die nutzungsbasierte Lizenzierung von Deadline Cloud verwendet. Entfernen Sie die Abschnitte, die nicht für Ihre Pipeline oder Produkte gelten, für die Sie nach Ablauf Ihrer Lizenzen keine nutzungsbasierte Lizenzierung verwenden möchten.
**Topics**
+ [Schritt 1: Konfigurieren Sie die Warteschlangenumgebung](#configure-queue-environment)
+ [Schritt 2: (Optional) Einrichtung der Lizenz-Proxyinstanz](#license-proxy)
+ [Schritt 3: Einrichtung der CloudFormation Vorlage](#byol-cfn-template)
## Schritt 1: Konfigurieren Sie die Warteschlangenumgebung
Sie können in Ihrer Warteschlange eine Warteschlangenumgebung für den Zugriff auf Ihren Lizenzserver konfigurieren. Stellen Sie zunächst sicher, dass Sie eine AWS Instanz mit Lizenzserverzugriff konfiguriert haben. Verwenden Sie dazu eine der folgenden Methoden:
+ Lizenzserver — Die Instanz hostet die Lizenzserver direkt.
+ Lizenzproxy — Die Instanz hat Netzwerkzugriff auf den Lizenzserver und leitet die Lizenzserverports an den Lizenzserver weiter. Einzelheiten zur Konfiguration einer Lizenz-Proxyinstanz finden Sie unter[Schritt 2: (Optional) Einrichtung der Lizenz-Proxyinstanz](#license-proxy).
Hinweise zur Konfiguration von Lizenzumgebungsvariablen finden Sie unter[Schritt 3: Eine Rendering-Anwendung mit einem Endpunkt Connect](cmf-ubl.md). Für ein benutzerdefiniertes Lizenzserver-Setup bleibt die Lizenzserveradresse localhost und nicht der Amazon VPC-Endpunkt.
**Um der Warteschlangenrolle die erforderlichen Berechtigungen hinzuzufügen**
1. Wählen Sie in der [Deadline Cloud-Konsole](https://console.aws.amazon.com/deadlinecloud/home) die Option **Gehe zum Dashboard** aus.
1. Wählen Sie im Dashboard die Farm und dann die Warteschlange aus, die Sie konfigurieren möchten.
1. Wählen Sie unter Warteschlangendetails > Servicerolle die Rolle aus.
1. Wählen Sie „**Berechtigung hinzufügen**“ und anschließend „**Inline-Richtlinie erstellen**“ aus.
1. Wählen Sie den JSON-Richtlinieneditor aus, kopieren Sie dann den folgenden Text und fügen Sie ihn in den Editor ein.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Action": [
"ssm:StartSession"
],
"Resource": [
"arn:aws:ssm:us-east-1::document/AWS-StartPortForwardingSession",
"arn:aws:ec2:us-east-1:111122223333:instance/instance_id"
]
}
]
}
```
------
1. Bevor Sie die neue Richtlinie speichern, ersetzen Sie die folgenden Werte im Richtlinientext:
+ `region`Ersetzen Sie durch die AWS Region, in der sich Ihre Farm befindet
+ `instance_id`Ersetzen Sie es durch die Instanz-ID für den Lizenzserver oder die Proxyinstanz, die Sie verwenden
+ `account_id`Ersetzen Sie es durch die AWS Kontonummer, die Ihre Farm enthält
1. Wählen Sie **Weiter** aus.
1. Geben Sie als Richtliniennamen ein**LicenseForwarding**.
1. Wählen Sie **Richtlinie erstellen** aus, um Ihre Änderungen zu speichern und die Richtlinie mit den erforderlichen Berechtigungen zu erstellen.
**Um der Warteschlange eine neue Warteschlangenumgebung hinzuzufügen**
1. Wählen Sie in der [Deadline Cloud-Konsole](https://console.aws.amazon.com/deadlinecloud/home) **Gehe zum Dashboard**, falls Sie dies noch nicht getan haben.
1. Wählen Sie im Dashboard die Farm und dann die Warteschlange aus, die Sie konfigurieren möchten.
1. Wählen Sie „**Warteschlangenumgebungen**“ > „**Aktionen**“ > „**Mit YAML neu erstellen**“.
1. Kopieren Sie den folgenden Text und fügen Sie ihn in den YAML-Skripteditor ein.
------
#### [ Windows ]
```
specificationVersion: "environment-2023-09"
parameterDefinitions:
- name: LicenseInstanceId
type: STRING
description: >
The Instance ID of the license server/proxy instance
default: ""
- name: LicenseInstanceRegion
type: STRING
description: >
The region containing this farm
default: ""
- name: LicensePorts
type: STRING
description: >
Comma-separated list of ports to be forwarded to the license server/proxy
instance. Example: "2701,2702,7075,2703,6101,1715,1716,1717,7054,7055,30304"
default: "2701,2702,7075,2703,6101,1715,1716,1717,7054,7055,30304"
environment:
name: BYOL License Forwarding
variables:
example_LICENSE: 2701@localhost
script:
actions:
onEnter:
command: bash
args: [ "{{Env.File.Enter}}" ]
onExit:
command: bash
args: [ "{{Env.File.Exit}}" ]
embeddedFiles:
- name: Enter
type: TEXT
runnable: True
data: |
curl "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/windows/SessionManagerPlugin.zip" -o "{{Session.WorkingDirectory}}/ssm-plugin.zip"
powershell -Command "Expand-Archive -Path '{{Session.WorkingDirectory}}/ssm-plugin.zip' -DestinationPath '{{Session.WorkingDirectory}}/ssm-plugin' -Force; Expand-Archive -Path '{{Session.WorkingDirectory}}/ssm-plugin/package.zip' -DestinationPath '{{Session.WorkingDirectory}}/ssm-plugin/package' -Force"
conda activate
python "{{Env.File.StartSession}}" "{{Session.WorkingDirectory}}/ssm-plugin/package/bin/session-manager-plugin.exe"
- name: Exit
type: TEXT
runnable: True
data: |
echo Killing SSM Manager Plugin PIDs: $BYOL_SSM_PIDS
for pid in ${BYOL_SSM_PIDS//,/ }; do kill $pid; done
- name: StartSession
type: TEXT
data: |
import boto3
import json
import subprocess
import sys
import os
import tempfile
instance_id = "{{Param.LicenseInstanceId}}"
region = "{{Param.LicenseInstanceRegion}}"
license_ports_list = "{{Param.LicensePorts}}".split(",")
ssm_client = boto3.client("ssm", region_name=region)
pids = []
for port in license_ports_list:
session_response = ssm_client.start_session(
Target=instance_id,
DocumentName="AWS-StartPortForwardingSession",
Parameters={"portNumber": [port], "localPortNumber": [port]}
)
cmd = [
sys.argv[1],
json.dumps(session_response),
region,
"StartSession",
"",
json.dumps({"Target": instance_id}),
f"https://ssm.{region}.amazonaws.com"
]
process = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
pids.append(process.pid)
print(f"SSM Port Forwarding Session started for port {port}")
print(f"openjd_env: BYOL_SSM_PIDS={','.join(str(pid) for pid in pids)}")
# Enabling UBL after the BYOL has run out requires prepending the BYOL configuration to the existing license setup
# Remove the sections that do not apply to your pipeline, or you do not want to use UBL after exhausting the BYOL licenses.
# The port numbers used may not match what your license server is serving.
# Arnold
os.environ["ADSKFLEX_LICENSE_FILE"] = f"2701@localhost;{os.environ.get('ADSKFLEX_LICENSE_FILE', '')}"
print(f"openjd_env: ADSKFLEX_LICENSE_FILE={os.environ['ADSKFLEX_LICENSE_FILE']}")
# Cinema4D
os.environ["g_licenseServerRLM"] = f"localhost:7057;{os.environ.get('g_licenseServerRLM', '')}"
print(f"openjd_env: g_licenseServerRLM={os.environ['g_licenseServerRLM']}")
# Nuke
os.environ["foundry_LICENSE"] = f"6101@localhost;{os.environ.get('foundry_LICENSE', '')}"
print(f"openjd_env: foundry_LICENSE={os.environ['foundry_LICENSE']}")
# SideFX
os.environ["SESI_LMHOST"] = f"localhost:1715;{os.environ.get('SESI_LMHOST', '')}"
print(f"openjd_env: SESI_LMHOST={os.environ['SESI_LMHOST']}")
# Redshift and Red Giant
os.environ["redshift_LICENSE"] = f"7054@localhost;7055@localhost;{os.environ.get('redshift_LICENSE', '')}"
print(f"openjd_env: redshift_LICENSE={os.environ['redshift_LICENSE']}")
# V-Ray doesn't support multiple license servers in a single environment variable
# See https://documentation.chaos.com/space/LIC5/125050770/Sharing+a+License+Configuration+in+a+Network
vray_license = os.environ.get('VRAY_AUTH_CLIENT_SETTINGS', '')
xml_content = """
localhost
30304"""
if vray_license and vray_license.startswith('licset://'):
server_parts = vray_license.removeprefix('licset://').split(':')
if len(server_parts) >= 2:
xml_content += f"""
{server_parts[0]}
{server_parts[1]}"""
xml_content += """
"""
temp_dir = tempfile.gettempdir()
xml_path = os.path.join(temp_dir, 'vrlclient.xml')
with open(xml_path, 'w') as f:
f.write(xml_content)
os.environ["VRAY_AUTH_CLIENT_FILE_PATH"] = temp_dir
print(f"openjd_env: VRAY_AUTH_CLIENT_FILE_PATH={os.environ['VRAY_AUTH_CLIENT_FILE_PATH']}")
# Clear the existing VRAY_AUTH_CLIENT_SETTINGS so only the vrlclient.xml file is used.
os.environ["VRAY_AUTH_CLIENT_SETTINGS"] = ''
print(f"openjd_env: VRAY_AUTH_CLIENT_SETTINGS={os.environ['VRAY_AUTH_CLIENT_SETTINGS']}")
# Print out the created xml file's contents
print(f"V-Ray configuration file: {xml_path}")
with open(xml_path, 'r') as f:
print(f"{f.read()}")
```
------
#### [ Linux ]
```
specificationVersion: "environment-2023-09"
parameterDefinitions:
- name: LicenseInstanceId
type: STRING
description: >
The Instance ID of the license server/proxy instance
default: ""
- name: LicenseInstanceRegion
type: STRING
description: >
The region containing this farm
default: ""
- name: LicensePorts
type: STRING
description: >
Comma-separated list of ports to be forwarded to the license server/proxy
instance. Example: "2701,2702,7075,2703,6101,1715,1716,1717,7054,7055,30304"
default: "2701,2702,7075,2703,6101,1715,1716,1717,7054,7055,30304"
environment:
name: BYOL License Forwarding
variables:
example_LICENSE: 2701@localhost
script:
actions:
onEnter:
command: bash
args: [ "{{Env.File.Enter}}" ]
onExit:
command: bash
args: [ "{{Env.File.Exit}}" ]
embeddedFiles:
- name: Enter
type: TEXT
runnable: True
data: |
curl https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_64bit/session-manager-plugin.rpm -Ls | rpm2cpio - | cpio -iv --to-stdout ./usr/local/sessionmanagerplugin/bin/session-manager-plugin > {{Session.WorkingDirectory}}/session-manager-plugin
chmod +x {{Session.WorkingDirectory}}/session-manager-plugin
conda activate
python {{Env.File.StartSession}} {{Session.WorkingDirectory}}/session-manager-plugin
- name: Exit
type: TEXT
runnable: True
data: |
echo Killing SSM Manager Plugin PIDs: $BYOL_SSM_PIDS
for pid in ${BYOL_SSM_PIDS//,/ }; do kill $pid; done
- name: StartSession
type: TEXT
data: |
import boto3
import json
import subprocess
import sys
import os
import tempfile
instance_id = "{{Param.LicenseInstanceId}}"
region = "{{Param.LicenseInstanceRegion}}"
license_ports_list = "{{Param.LicensePorts}}".split(",")
ssm_client = boto3.client("ssm", region_name=region)
pids = []
for port in license_ports_list:
session_response = ssm_client.start_session(
Target=instance_id,
DocumentName="AWS-StartPortForwardingSession",
Parameters={"portNumber": [port], "localPortNumber": [port]}
)
cmd = [
sys.argv[1],
json.dumps(session_response),
region,
"StartSession",
"",
json.dumps({"Target": instance_id}),
f"https://ssm.{region}.amazonaws.com"
]
process = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
pids.append(process.pid)
print(f"SSM Port Forwarding Session started for port {port}")
print(f"openjd_env: BYOL_SSM_PIDS={','.join(str(pid) for pid in pids)}")
# Enabling UBL after the BYOL has run out requires prepending the BYOL configuration to the existing license setup
# Remove the sections that do not apply to your pipeline, or you do not want to use UBL after exhausting the BYOL licenses.
# The port numbers used may not match what your license server is serving.
# Arnold
os.environ["ADSKFLEX_LICENSE_FILE"] = f"2701@localhost:{os.environ.get('ADSKFLEX_LICENSE_FILE', '')}"
print(f"openjd_env: ADSKFLEX_LICENSE_FILE={os.environ['ADSKFLEX_LICENSE_FILE']}")
# Nuke
os.environ["foundry_LICENSE"] = f"6101@localhost:{os.environ.get('foundry_LICENSE', '')}"
print(f"openjd_env: foundry_LICENSE={os.environ['foundry_LICENSE']}")
# SideFX
os.environ["SESI_LMHOST"] = f"localhost:1715;{os.environ.get('SESI_LMHOST', '')}"
print(f"openjd_env: SESI_LMHOST={os.environ['SESI_LMHOST']}")
# Redshift and Red Giant
os.environ["redshift_LICENSE"] = f"7054@localhost:7055@localhost:{os.environ.get('redshift_LICENSE', '')}"
print(f"openjd_env: redshift_LICENSE={os.environ['redshift_LICENSE']}")
# V-Ray doesn't support multiple license servers in a single environment variable
# See https://documentation.chaos.com/space/LIC5/125050770/Sharing+a+License+Configuration+in+a+Network
vray_license = os.environ.get('VRAY_AUTH_CLIENT_SETTINGS', '')
xml_content = """
localhost
30304"""
if vray_license and vray_license.startswith('licset://'):
server_parts = vray_license.removeprefix('licset://').split(':')
if len(server_parts) >= 2:
xml_content += f"""
{server_parts[0]}
{server_parts[1]}"""
xml_content += """
"""
temp_dir = tempfile.gettempdir()
xml_path = os.path.join(temp_dir, 'vrlclient.xml')
with open(xml_path, 'w') as f:
f.write(xml_content)
os.environ["VRAY_AUTH_CLIENT_FILE_PATH"] = temp_dir
print(f"openjd_env: VRAY_AUTH_CLIENT_FILE_PATH={os.environ['VRAY_AUTH_CLIENT_FILE_PATH']}")
# Clear the existing VRAY_AUTH_CLIENT_SETTINGS so only the vrlclient.xml file is used.
os.environ["VRAY_AUTH_CLIENT_SETTINGS"] = ''
print(f"openjd_env: VRAY_AUTH_CLIENT_SETTINGS={os.environ['VRAY_AUTH_CLIENT_SETTINGS']}")
# Print out the created xml file's contents
print(f"V-Ray configuration file: {xml_path}")
with open(xml_path, 'r') as f:
print(f"{f.read()}")
```
------
1. Bevor Sie die Warteschlangenumgebung speichern, nehmen Sie nach Bedarf die folgenden Änderungen am Umgebungstext vor:
+ Aktualisieren Sie die Standardwerte für die folgenden Parameter, sodass sie Ihrer Umgebung entsprechen:
+ **LicenseInstanceID** — Die Amazon EC2 EC2-Instance-ID Ihres Lizenzservers oder Ihrer Proxy-Instance
+ **LicenseInstanceRegion**— Die AWS Region, in der sich Ihre Farm befindet
+ **LicensePorts**— Eine durch Kommas getrennte Liste von Ports, die an den Lizenzserver oder die Proxyinstanz weitergeleitet werden sollen (z. B. 2700,2701)
+ Wenn Sie die nutzungsbasierte Lizenzierung (UBL) verwenden möchten, nachdem Bring Your Own License (BYOL) erschöpft ist, stellen Sie sicher, dass der Port für Ihren Lizenzserver korrekt ist. Wenn Sie UBL nicht mehr verwenden möchten, nachdem BYOL aufgebraucht ist, fügen Sie dem Variablenbereich alle erforderlichen Umgebungsvariablen für die Lizenzierung hinzu.
Diese Variablen sollten den Link DCCs zu localhost auf dem Lizenzserverport weiterleiten. Wenn Ihr Foundry-Lizenzserver beispielsweise Port 6101 abhört, würden Sie die Variable als hinzufügen. **foundry\$1LICENSE: 6101@localhost**
1. (Optional) Sie können die **Priorität** auf **0** belassen oder sie so ändern, dass die Priorität in Umgebungen mit mehreren Warteschlangen unterschiedlich angeordnet wird.
1. Wählen Sie „**Warteschlangenumgebung erstellen**“, um die neue Umgebung zu speichern.
Wenn die Warteschlangenumgebung festgelegt ist, rufen Aufträge, die an diese Warteschlange gesendet werden, Lizenzen vom konfigurierten Lizenzserver ab.
## Schritt 2: (Optional) Einrichtung der Lizenz-Proxyinstanz
Als Alternative zur Verwendung eines Lizenzservers können Sie einen Lizenzproxy verwenden. Um einen Lizenz-Proxy zu erstellen, erstellen Sie eine neue Amazon Linux 2023-Instance, die Netzwerkzugriff auf den Lizenzserver hat. Bei Bedarf können Sie diesen Zugriff über eine VPN-Verbindung konfigurieren. Weitere Informationen finden Sie unter [VPN-Verbindungen](https://docs.aws.amazon.com/vpc/latest/userguide/vpn-connections.html) im *Amazon VPC-Benutzerhandbuch*.
Um eine Lizenz-Proxyinstanz für Deadline Cloud einzurichten, folgen Sie den Schritten in diesem Verfahren. Führen Sie die folgenden Konfigurationsschritte auf dieser neuen Instanz durch, um die Weiterleitung des Lizenzverkehrs an Ihren Lizenzserver zu ermöglichen
1. Geben Sie Folgendes ein, um das HAProxy Paket zu installieren
```
sudo yum install haproxy
```
1. Aktualisieren Sie den Abschnitt listen license-server der Konfigurationsdatei**/etc/haproxy/haproxy.cfg** wie folgt:
1. Ersetzen Sie **LicensePort1** und **LicensePort2** durch die Portnummern, die an den Lizenzserver weitergeleitet werden sollen. Fügen Sie kommagetrennte Werte hinzu oder entfernen Sie sie, um der erforderlichen Anzahl von Anschlüssen gerecht zu werden.
1. **LicenseServerHost**Ersetzen Sie durch den Hostnamen oder die IP-Adresse des Lizenzservers.
```
lobal
log 127.0.0.1 local2
chroot /var/lib/haproxy
user haproxy
group haproxy
daemon
defaults
timeout queue 1m
timeout connect 10s
timeout client 1m
timeout server 1m
timeout http-keep-alive 10s
timeout check 10s
listen license-server
bind *:LicensePort1,*:LicensePort2
server license-server LicenseServerHost
```
1. Führen Sie die folgenden Befehle aus, um den HAProxy Dienst zu aktivieren und zu starten:
```
sudo systemctl enable haproxy
sudo service haproxy start
```
Nach Abschluss der Schritte sollten Lizenzanfragen, die aus der Weiterleitungswarteschlangenumgebung an localhost gesendet werden, an den angegebenen Lizenzserver weitergeleitet werden.
## Schritt 3: Einrichtung der CloudFormation Vorlage
Sie können eine CloudFormation Vorlage verwenden, um eine gesamte Farm so zu konfigurieren, dass sie Ihre eigene Lizenzierung verwendet.
1. Ändern Sie die im nächsten Schritt bereitgestellte Vorlage, um dem Variablenbereich unter Umgebung alle erforderlichen ****BYOLQueueUmgebungsvariablen**** für die Lizenzierung hinzuzufügen.
1. Verwenden Sie die folgende CloudFormation Vorlage.
```
AWSTemplateFormatVersion: 2010-09-09
Description: "Create &ADC; resources for BYOL"
Parameters:
LicenseInstanceId:
Type: AWS::EC2::Instance::Id
Description: Instance ID for the license server/proxy instance
LicensePorts:
Type: String
Description: Comma-separated list of ports to forward to the license instance
Resources:
JobAttachmentBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: !Sub byol-example-ja-bucket-${AWS::AccountId}-${AWS::Region}
BucketEncryption:
ServerSideEncryptionConfiguration:
- ServerSideEncryptionByDefault:
SSEAlgorithm: AES256
Farm:
Type: AWS::Deadline::Farm
Properties:
DisplayName: BYOLFarm
QueuePolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
ManagedPolicyName: BYOLQueuePolicy
PolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Action:
- s3:GetObject
- s3:PutObject
- s3:ListBucket
- s3:GetBucketLocation
Resource:
- !Sub ${JobAttachmentBucket.Arn}
- !Sub ${JobAttachmentBucket.Arn}/job-attachments/*
Condition:
StringEquals:
aws:ResourceAccount: !Sub ${AWS::AccountId}
- Effect: Allow
Action: logs:GetLogEvents
Resource: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:log-group:/aws/deadline/${Farm.FarmId}/*
- Effect: Allow
Action:
- s3:ListBucket
- s3:GetObject
Resource:
- "*"
Condition:
ArnLike:
s3:DataAccessPointArn:
- arn:aws:s3:*:*:accesspoint/deadline-software-*
StringEquals:
s3:AccessPointNetworkOrigin: VPC
BYOLSSMPolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
ManagedPolicyName: BYOLSSMPolicy
PolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Action:
- ssm:StartSession
Resource:
- !Sub arn:aws:ssm:${AWS::Region}::document/AWS-StartPortForwardingSession
- !Sub arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:instance/${LicenseInstanceId}
WorkerPolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
ManagedPolicyName: BYOLWorkerPolicy
PolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Action:
- logs:CreateLogStream
Resource: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:log-group:/aws/deadline/${Farm.FarmId}/*
Condition:
ForAnyValue:StringEquals:
aws:CalledVia:
- deadline.amazonaws.com
- Effect: Allow
Action:
- logs:PutLogEvents
- logs:GetLogEvents
Resource: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:log-group:/aws/deadline/${Farm.FarmId}/*
QueueRole:
Type: AWS::IAM::Role
Properties:
RoleName: BYOLQueueRole
ManagedPolicyArns:
- !Ref QueuePolicy
- !Ref BYOLSSMPolicy
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Action:
- sts:AssumeRole
Principal:
Service:
- credentials.deadline.amazonaws.com
- deadline.amazonaws.com
Condition:
StringEquals:
aws:SourceAccount: !Sub ${AWS::AccountId}
ArnEquals:
aws:SourceArn: !Ref Farm
WorkerRole:
Type: AWS::IAM::Role
Properties:
RoleName: BYOLWorkerRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/AWSDeadlineCloud-FleetWorker
- !Ref WorkerPolicy
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Action:
- sts:AssumeRole
Principal:
Service: credentials.deadline.amazonaws.com
Queue:
Type: AWS::Deadline::Queue
Properties:
DisplayName: BYOLQueue
FarmId: !GetAtt Farm.FarmId
RoleArn: !GetAtt QueueRole.Arn
JobRunAsUser:
Posix:
Group: ""
User: ""
RunAs: WORKER_AGENT_USER
JobAttachmentSettings:
RootPrefix: job-attachments
S3BucketName: !Ref JobAttachmentBucket
Fleet:
Type: AWS::Deadline::Fleet
Properties:
DisplayName: BYOLFleet
FarmId: !GetAtt Farm.FarmId
MinWorkerCount: 1
MaxWorkerCount: 2
Configuration:
ServiceManagedEc2:
InstanceCapabilities:
VCpuCount:
Min: 4
Max: 16
MemoryMiB:
Min: 4096
Max: 16384
OsFamily: LINUX
CpuArchitectureType: x86_64
InstanceMarketOptions:
Type: on-demand
RoleArn: !GetAtt WorkerRole.Arn
QFA:
Type: AWS::Deadline::QueueFleetAssociation
Properties:
FarmId: !GetAtt Farm.FarmId
FleetId: !GetAtt Fleet.FleetId
QueueId: !GetAtt Queue.QueueId
CondaQueueEnvironment:
Type: AWS::Deadline::QueueEnvironment
Properties:
FarmId: !GetAtt Farm.FarmId
Priority: 5
QueueId: !GetAtt Queue.QueueId
TemplateType: YAML
Template: |
specificationVersion: 'environment-2023-09'
parameterDefinitions:
- name: CondaPackages
type: STRING
description: >
This is a space-separated list of conda package match specifications to install for the job.
E.g. "blender=3.6" for a job that renders frames in Blender 3.6.
See https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/pkg-specs.html#package-match-specifications
default: ""
userInterface:
control: LINE_EDIT
label: Conda Packages
- name: CondaChannels
type: STRING
description: >
This is a space-separated list of conda channels from which to install packages. &ADC; SMF packages are
installed from the "deadline-cloud" channel that is configured by &ADC;.
Add "conda-forge" to get packages from the https://conda-forge.org/ community, and "defaults" to get packages
from Anaconda Inc (make sure your usage complies with https://www.anaconda.com/terms-of-use).
default: "deadline-cloud"
userInterface:
control: LINE_EDIT
label: Conda Channels
environment:
name: Conda
script:
actions:
onEnter:
command: "conda-queue-env-enter"
args: ["{{Session.WorkingDirectory}}/.env", "--packages", "{{Param.CondaPackages}}", "--channels", "{{Param.CondaChannels}}"]
onExit:
command: "conda-queue-env-exit"
BYOLQueueEnvironment:
Type: AWS::Deadline::QueueEnvironment
Properties:
FarmId: !GetAtt Farm.FarmId
Priority: 10
QueueId: !GetAtt Queue.QueueId
TemplateType: YAML
Template: !Sub |
specificationVersion: "environment-2023-09"
parameterDefinitions:
- name: LicenseInstanceId
type: STRING
description: >
The Instance ID of the license server/proxy instance
default: ""
- name: LicenseInstanceRegion
type: STRING
description: >
The region containing this farm
default: ""
- name: LicensePorts
type: STRING
description: >
Comma-separated list of ports to be forwarded to the license server/proxy
instance. Example: "2701,2702,7075,2703,6101,1715,1716,1717,7054,7055,30304"
default: "2701,2702,7075,2703,6101,1715,1716,1717,7054,7055,30304"
environment:
name: BYOL License Forwarding
variables:
example_LICENSE: 2701@localhost
script:
actions:
onEnter:
command: bash
args: [ "{{Env.File.Enter}}" ]
onExit:
command: bash
args: [ "{{Env.File.Exit}}" ]
embeddedFiles:
- name: Enter
type: TEXT
runnable: True
data: |
curl https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_64bit/session-manager-plugin.rpm -Ls | rpm2cpio - | cpio -iv --to-stdout ./usr/local/sessionmanagerplugin/bin/session-manager-plugin > {{Session.WorkingDirectory}}/session-manager-plugin
chmod +x {{Session.WorkingDirectory}}/session-manager-plugin
conda activate
python {{Env.File.StartSession}} {{Session.WorkingDirectory}}/session-manager-plugin
- name: Exit
type: TEXT
runnable: True
data: |
echo Killing SSM Manager Plugin PIDs: $BYOL_SSM_PIDS
for pid in ${BYOL_SSM_PIDS//,/ }; do kill $pid; done
- name: StartSession
type: TEXT
data: |
import boto3
import json
import subprocess
import sys
import os
import tempfile
instance_id = "{{Param.LicenseInstanceId}}"
region = "{{Param.LicenseInstanceRegion}}"
license_ports_list = "{{Param.LicensePorts}}".split(",")
ssm_client = boto3.client("ssm", region_name=region)
pids = []
for port in license_ports_list:
session_response = ssm_client.start_session(
Target=instance_id,
DocumentName="AWS-StartPortForwardingSession",
Parameters={"portNumber": [port], "localPortNumber": [port]}
)
cmd = [
sys.argv[1],
json.dumps(session_response),
region,
"StartSession",
"",
json.dumps({"Target": instance_id}),
f"https://ssm.{region}.amazonaws.com"
]
process = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
pids.append(process.pid)
print(f"SSM Port Forwarding Session started for port {port}")
print(f"openjd_env: BYOL_SSM_PIDS={','.join(str(pid) for pid in pids)}")
# Enabling UBL after the "bring your own license" (BYOL) has run out requires prepending the BYOL configuration to the existing license setup
# Remove the sections that do not apply to your pipeline, or you do not want to use UBL after exhausting the BYOL licenses.
# The port numbers used may not match what your license server is serving.
# Arnold
os.environ["ADSKFLEX_LICENSE_FILE"] = f"2701@localhost:{os.environ.get('ADSKFLEX_LICENSE_FILE', '')}"
print(f"openjd_env: ADSKFLEX_LICENSE_FILE={os.environ['ADSKFLEX_LICENSE_FILE']}")
# Nuke
os.environ["foundry_LICENSE"] = f"6101@localhost:{os.environ.get('foundry_LICENSE', '')}"
print(f"openjd_env: foundry_LICENSE={os.environ['foundry_LICENSE']}")
# SideFX
os.environ["SESI_LMHOST"] = f"localhost:1715;{os.environ.get('SESI_LMHOST', '')}"
print(f"openjd_env: SESI_LMHOST={os.environ['SESI_LMHOST']}")
# Redshift and Red Giant
os.environ["redshift_LICENSE"] = f"7054@localhost:7055@localhost:{os.environ.get('redshift_LICENSE', '')}"
print(f"openjd_env: redshift_LICENSE={os.environ['redshift_LICENSE']}")
# V-Ray doesn't support multiple license servers in a single environment variable
# See https://documentation.chaos.com/space/LIC5/125050770/Sharing+a+License+Configuration+in+a+Network
vray_license = os.environ.get('VRAY_AUTH_CLIENT_SETTINGS', '')
xml_content = """
localhost
30304"""
if vray_license and vray_license.startswith('licset://'):
server_parts = vray_license.removeprefix('licset://').split(':')
if len(server_parts) >= 2:
xml_content += f"""
{server_parts[0]}
{server_parts[1]}"""
xml_content += """
"""
temp_dir = tempfile.gettempdir()
xml_path = os.path.join(temp_dir, 'vrlclient.xml')
with open(xml_path, 'w') as f:
f.write(xml_content)
os.environ["VRAY_AUTH_CLIENT_FILE_PATH"] = temp_dir
print(f"openjd_env: VRAY_AUTH_CLIENT_FILE_PATH={os.environ['VRAY_AUTH_CLIENT_FILE_PATH']}")
# Clear the existing VRAY_AUTH_CLIENT_SETTINGS so only the vrlclient.xml file is used.
os.environ["VRAY_AUTH_CLIENT_SETTINGS"] = ''
print(f"openjd_env: VRAY_AUTH_CLIENT_SETTINGS={os.environ['VRAY_AUTH_CLIENT_SETTINGS']}")
# Print out the created xml file's contents
print(f"V-Ray configuration file: {xml_path}")
with open(xml_path, 'r') as f:
print(f"{f.read()}")
```
1. Geben Sie bei der Bereitstellung der CloudFormation Vorlage die folgenden Parameter an:
+ Aktualisieren Sie die **LicenseInstanceID** mit der Amazon EC2 EC2-Instance-ID Ihres Lizenzservers oder Ihrer Proxy-Instance
+ Aktualisieren Sie die **LicensePorts**mit einer durch Kommas getrennten Liste von Ports, die an den Lizenzserver oder die Proxy-Instance weitergeleitet werden sollen (z. B. 2700,2701)
+ Fügen Sie die Lizenzumgebungsvariablen hinzu, indem Sie sie in der Vorlage ersetzen **example\$1LICENSE: 2700@localhost**
1. Stellen Sie die Vorlage bereit, um Ihre Farm mit der Funktion „Bring Your Own License“ einzurichten.