Integration von an AWS Marketplace for Containers Anywhere mit License Manager - AWS Marketplace

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.

Integration von an AWS Marketplace for Containers Anywhere mit License Manager

Als AWS Marketplace Verkäufer können Sie eine Integration in AWS License Manager ein AWS Marketplace for Containers Anywhere-Produkt für Amazon EKS Anywhere, Amazon ECS Anywhere EC2, Amazon oder eine lokale Infrastruktur vornehmen. Die folgenden Abschnitte enthalten Anweisungen für diese Integration.

Allgemeine Informationen zur License Manager Manager-Integration mit AWS Marketplace, einschließlich verfügbarer Lizenzmodelle, finden Sie unterVertragspreise für Containerprodukte mit AWS License Manager. Weitere Informationen AWS License Manager dazu finden Sie im AWS License Manager Benutzerhandbuch und im AWS License ManagerAbschnitt der AWS CLI Befehlsreferenz.

Integration eines AWS Marketplace for Containers Anywhere-Produkts mit License Manager

Verwenden Sie die folgenden Anweisungen, um Ihr AWS Marketplace for Containers Anywhere-Produkt in zu integrieren AWS License Manager.

Um Ihr AWS Marketplace for Containers Anywhere-Produkt mit License Manager zu integrieren
  1. Öffnen Sie einen Webbrowser, und melden Sie sich am AWS Marketplace Management Portal an.

  2. Erstellen Sie eine Produkt-ID für Ihr Container-Produkt, indem Sie die folgenden Schritte ausführen. Sie werden diese ID in Ihrem Container-Image für Lizenzprüfungen in einem späteren Schritt verwenden.

    1. Erweitern Sie in der Menüleiste Assets (Objekte) und wählen Sie Container.

    2. Geben Sie einen kundenorientierten Namen für Ihr Produkt ein und wählen Sie Create. Sie können diesen Namen später ändern.

    3. Notieren Sie sich die Produkt-ID. Sie werden sie verwenden, wenn Sie die Produktpreisdetails erstellen oder aktualisieren.

      Tipp

      Wenn Sie Ihre Produkt-ID verlieren, finden Sie sie in der, AWS Marketplace Management Portal indem Sie im Assets-Menü die Option Container auswählen. Auf der Seite „Container“ wird eine Liste Ihrer Produkte mit dem zugehörigen Produkt angezeigt IDs.

  3. Laden Sie das neueste öffentliche AWS SDK herunter und installieren Sie es dann in Ihrer Container-Anwendung. Installationsanweisungen für Ihr bevorzugtes AWS SDK finden Sie unter Tools to Build on AWS.

    Anmerkung

    Um die License Manager Manager-API-Operationen von Amazon EKS Anywhere oder einem Kubernetes-Cluster aufzurufen, der nicht von bereitgestellt wird AWS, müssen Sie ein unterstütztes AWS SDK verwenden. Eine Liste der unterstützten SDKs finden Sie AWS SDKs unter Ein unterstütztes AWS SDK verwenden.

  4. Erstellen Sie einen AWS License Manager Client mit einem benutzerdefinierten Anmeldeinformationsanbieter, sodass er Anmeldeinformationen für die sowohl lokal AWS als auch lokal bereitgestellte Containeranwendung bereitstellen kann. Den vollständigen Quellcode für einen benutzerdefinierten Anmeldeinformationsanbieter finden Sie in den LicenseCredentialProvider folgenden Abschnitten:

    LicenseCredentialsProvidererweitert die standardmäßige Anbieterkette für Anmeldeinformationen des AWS SDK für die lokale Verwendung um Folgendes: LicenseManagerTokenCredentialsProvider Dadurch werden Anmeldeinformationen mithilfe von License Manager OIDC ausgestellten Identitätstoken in lokalen Umgebungen bereitgestellt. Sie müssen den Quellcode für LicenseCredentialsProvider in den Klassenpfad Ihrer Anwendung aufnehmen.

    Anmerkung

    DefaultCredentialsProviderDurch die Erweiterung kann dieselbe Containeranwendung Anmeldeinformationen abrufen, wenn sie in AWS und in einer lokalen Umgebung ausgeführt wird. Wenn die Containeranwendung bereits eine benutzerdefinierte Anbieterkette anstelle der Standardanbieterkette verwendet, kann sie auch erweitert werden, indem sie der benutzerdefinierten Kette LicenseManagerTokenCredentialsProvider hinzugefügt wird.

    Der folgende Codeausschnitt ist ein Beispiel für die Erstellung eines AWS License Manager Clients mit Java.

    LicenseManagerClientBuilder clientBuilder = LicenseManagerClient.builder().credentialsProvider(LicenseCredentialsProvider.create());
  5. Rufen Sie den CheckoutLicense API-Vorgang auf, indem Sie den aws license-manager checkout-license Befehl für jedes kostenpflichtige Container-Image in Ihrem Produktangebot verwenden. Dadurch wird überprüft, ob der Käufer berechtigt ist, eine Lizenz für Ihre Anwendung zu verwenden. Wenn der Käufer Anspruch auf den Antrag hat, ist er CheckoutLicense erfolgreich und gibt die angeforderten Rechte und deren Wert zurück. Wenn der Käufer keinen Anspruch auf den Antrag hat, wird eine Ausnahme CheckoutLicense ausgelöst.

    Die folgenden Parameter sind beim Aufrufen des CheckoutLicense API-Vorgangs erforderlich:

    • CheckoutType— Die gültigen Werte sind PROVISIONAL oderPERPETUAL:

      • Verwenden Sie diese OptionPERPETUAL, wenn die Anzahl der ausgecheckten Berechtigungen aus dem Pool erschöpft sein wird.

        Beispiel: Der Käufer ist berechtigt, 500 GB an Daten zu verarbeiten. Bei der weiteren Verarbeitung der Daten wird die Menge aus dem Pool von 500 GB entnommen und ausgeschöpft.

      • Wird PROVISIONAL für variable Lizenzberechtigungen verwendet, bei denen die Berechtigungen aus dem Pool ausgecheckt und nach Gebrauch zurückgegeben werden.

        Beispiel: Der Benutzer hat Anspruch auf 500 gleichzeitige Benutzer in der Anwendung. Wenn sich Benutzer an- oder abmelden, werden die Benutzer aus dem Pool von 500 Benutzern gezogen oder wieder aufgenommen. Weitere Informationen zu variablen Lizenzberechtigungen finden Sie unterFlexible Lizenzberechtigungen mit License Manager.

    • ClientToken— Eine eindeutige Kennung, bei der Groß- und Kleinschreibung berücksichtigt wird. Wir empfehlen, für jede eindeutige Anfrage eine zufällige UUID zu verwenden.

    • Entitlements— Eine Liste von Berechtigungen, die ausgecheckt werden müssen.

      • Geben Sie für Funktionsberechtigungen die Unit Eigenschaften Name und wie folgt an.

        { "Name": "<Entitlement_Name>", "Unit": "None" }
      • Geben Sie für gezählte Berechtigungen die Count Eigenschaften NameUnit, und wie folgt an.

        { "Name": "<Entitlement_Name>", "Unit": "<Entitlement_Unit>", "Value": <Desired_Count> }
    • KeyFingerprint— Der wichtigste Fingerabdruck für Lizenzen, die von AWS Marketplace uns ausgestellt wurden. aws:294406891311:AWS/Marketplace:issuer-fingerprint Durch die Verwendung dieses Schlüssel-Fingerabdrucks wird sichergestellt, dass die Lizenz von einer unzuverlässigen Stelle ausgestellt wurde AWS Marketplace und nicht von einer unzuverlässigen Stelle.

    • ProductSKU— Die Produkt-ID, die AWS Marketplace Management Portal in den vorherigen Schritten generiert wurde.

    Das folgende Snippet ist ein Beispiel für einen Aufruf unter Verwendung der CheckoutLicense API-Operation unter Verwendung von. AWS CLI

    aws license-manager checkout-license \ --product-sku "2205b290-19e6-4c76-9eea-377d6bf71a47" \ --checkout-type "PROVISIONAL" \ --client-token "79464194dca9429698cc774587a603a1" \ --entitlements "Name=AWS::Marketplace::Usage/Drawdown/DataConsumption, Value=10, Unit=Gigabytes" \ --key-fingerprint "aws:294406891311:AWS/Marketplace:issuer-fingerprint"
    Anmerkung

    Um Lizenzen zu überprüfen, benötigen Containeranwendungen ausgehenden Netzwerkzugriff, um License Manager verwenden zu können. Bei lokal bereitgestellten Anwendungen kann es zu einem unzuverlässigen oder langsamen ausgehenden Netzwerkzugriff kommen. Diese Anwendungen sollten angemessene Wiederholungsversuche beim Aufrufen von License Manager beinhalten. Weitere Informationen finden Sie unter Bewährte Methoden für die Integration mit License Manager für lokale Bereitstellungen.

  6. Rufen Sie den CheckoutLicense API-Vorgang in regelmäßigen Abständen auf, um etwaige Änderungen an den Kundenlizenzen aufgrund von Verlängerungen, Upgrades oder Stornierungen am zu ermitteln. AWS Marketplace Die Schrittfrequenz hängt von der Anwendung ab. Wir empfehlen, die Lizenzen einmal täglich zu überprüfen, damit Änderungen automatisch und ohne Eingreifen des Käufers übernommen werden.

    Eine lokal bereitgestellte Anwendung verfügt möglicherweise über einen unzuverlässigen ausgehenden Netzwerkzugriff, um die Lizenzen regelmäßig zu überprüfen. In solchen Fällen sollte die Anwendung zwischengespeicherte Lizenzen verwenden, um eine ausreichende Ausfallsicherheit zu gewährleisten. Weitere Informationen finden Sie unter Bewährte Methoden für die Integration mit License Manager für lokale Bereitstellungen.

  7. Nachdem Sie den CheckoutLicense Aufruf in Ihre Container-Anwendung integriert haben, erstellen Sie eine neue Version Ihres Docker-Container-Images mit den Änderungen.

  8. Aktualisieren Sie das Helm-Diagramm Ihrer Anwendung, sodass ein Kubernetes-Secret als optionale Eingabe akzeptiert wird, das die Konfiguration für den Zugriff auf Lizenzen mit License Manager enthält. APIs Das Konfigurationsgeheimnis enthält ein von License Manager ausgestelltes Identitätstoken und eine AWS Identity and Access Management Rolle, die von dem zuvor beschriebenen Anbieter für benutzerdefinierte Anmeldeinformationen verwendet wird, um AWS Anmeldeinformationen für den Aufruf von License Manager abzurufen, APIs wenn die Containeranwendung lokal bereitgestellt wird. Fügen Sie außerdem den AWS-Region als Eingabe mit dem Standardwert hinzu. us-east-1

    Käufer, die die Container-Anwendung vor Ort einsetzen, können das Kubernetes-Geheimnis über das AWS Marketplace Einkaufserlebnis für Container-Produkte erstellen. Geben Sie den geheimen Namen von Kubernetes als Eingabe für den Befehl ein. helm install Das Konfigurationsgeheimnis ist im folgenden Format konfiguriert.

    apiVersion: v1 kind: Secret metadata: name: aws-marketplace-license-config type: Opaque stringData: license_token: <token_value> // License Manager issued JWT token iam_role: <role_arn> // AWS Identity and Access Management role to assume with license token
  9. Aktualisieren Sie die Vorlage für die Anwendungsbereitstellung im Helm-Diagramm für in integrierte Container-Images AWS License Manager , sodass sie Folgendes enthält:

    • Servicekonto für Pod — Das Servicekonto ist für Helm-Bereitstellungen auf Amazon EKS erforderlich. Es wird verwendet, um Berechtigungen zum Aufrufen von License Manager Manager-API-Vorgängen zu erhalten, indem IAM-Rollen für das Dienstkonto auf dem Container-Image eingerichtet werden. Weitere Informationen zu IAM-Rollen für Dienstkonten finden Sie unter IAM-Rollen für Dienstkonten.

    • Lizenzzugriff für lokale Bereitstellungen — Das geheime Lizenzkonfigurationsgeheimnis ist erforderlich, um Anmeldeinformationen und entsprechende Berechtigungen zum Aufrufen von License Manager Manager-API-Vorgängen für Helm-Bereitstellungen in lokalen Umgebungen bereitzustellen. Käufer werden das Lizenzgeheimnis anhand der Kundenerfahrung generieren und Helm zur Verfügung stellen. AWS Marketplace

    Der folgende Codeausschnitt ist ein Beispiel für eine Bereitstellungsspezifikation mit dem Dienstkonto, der Lizenzkonfiguration und dem Image-Pull-Secret.

    apiVersion: apps/v1 kind: Deployment metadata: name: example-app spec: replicas: 1 selector: matchLabels: app: example-app template: metadata: labels: app: example-app spec: // Service account for pod serviceAccountName: {{ .Values.serviceAccountName }} containers: - name: example-app image: example-app ports: - containerPort: 8001 // Add the following conditional attributes {{ - if .Values.awsmp.licenseConfigSecretName }} //Mount the license volume to the container image volumeMounts: - name: awsmp-product-license mountPath: "/var/run/secrets/product-license" //Add following environment variable to container for credential provider env: - name: AWS_WEB_IDENTITY_REFRESH_TOKEN_FILE value: "/var/run/secrets/product-license/license_token" - name: AWS_ROLE_ARN valueFrom: secretKeyRef: name: {{ .Values.aws.licenseConfigSecretName }} key: iam_role //Mount the license secret as a volume to the pod volumes: - name: awsmp-product-license secret: secretName: {{ .Values.aws.licenseConfigSecretName }} optional: true {{ - end }}
    Anmerkung

    Das geheime Lizenzkonfigurationsgeheimnis ist optional. Käufer verwenden den Wert nur für Bereitstellungen vor Ort. Für AWS Bereitstellungen muss die Bereitstellungsspezifikation ein Dienstkonto für die integrierten License Manager Manager-Images enthalten.

  10. Testen Sie die License Manager Manager-Integration lokal und auf Amazon EKS, indem Sie die Schritte in den folgenden Abschnitten ausführen:

    1. Die License Manager Manager-Integration lokal testen

    2. Testen der License Manager Manager-Integration auf Amazon EKS

  11. Nachdem Sie die License Manager Manager-Integration sowohl vor Ort AWS als auch vor Ort erfolgreich verifiziert haben, können Sie Ihre Container-Produktliste erstellen, indem Sie die Schritte unter befolgen. Überblick: Erstellen Sie ein Container-Produkt

Die License Manager Manager-Integration lokal testen

Sie können Minikube oder ein anderes Setup verwenden, um die License Manager Manager-Integration auf einem beliebigen Kubernetes-Cluster lokal zu testen. Stellen Sie sicher, dass der Kubernetes-Cluster über einen ausgehenden Internetzugang verfügt, um License Manager Manager-API-Operationen aufzurufen.

Um eine License Manager Manager-Integration lokal zu testen
  1. Erstellen Sie eine Testlizenz in einem Testverkäuferkonto mit den gewünschten Berechtigungen. Informationen zum Einrichten einer Testlizenz finden Sie CreateLicensein der AWS License Manager API-Referenz. Oder verwenden Sie das folgende Skript, um eine Testlizenz zu erstellen und anschließend einem Testkäuferkonto eine Lizenz zu gewähren, um die Lizenz zu nutzen. Das folgende Skript verwendet Anmeldeinformationen für das Testverkäuferkonto.

    read -p 'AWS Account for test buyer: ' TEST_BUYER_ACCOUNT_ID read -p 'License entitlements: ' ENTITLEMENTS # TEST_SELLER_ACCOUNT_ID="109876543210" # ENTITLEMENTS="{\"Name\": \"ByData\",\"MaxCount\": 1000,\"Overage\":true,\"Unit\": \"Gigabits\",\"AllowCheckIn\": true}" # Create License NOW=$(date +"%Y-%m-%dT00:00:00+00:00") PRODUCT_NAME="My awesome product" PRODUCT_SKU="c97b7825-44c4-4f42-b025-12baa4c171e0" LICENSE_BENEFICIARY=" arn:aws:iam::$TEST_BUYER_ACCOUNT_ID:root " LICENSE_ISSUER_NAME="test-seller" LICENSE_NAME="test-seller-license" CLIENT_TOKEN="b3920968-a94f-4547-af07-3dd232319367" CONSUMPTION_TTL=180 CONSUMPTION_RENEW_TYPE="None" HOME_REGION="us-east-1" LICENSE_ARN=$(aws license-manager create-license --license-name "$LICENSE_NAME" --product-name "$PRODUCT_NAME" --product-sku "$PRODUCT_SKU" --issuer Name="$LICENSE_ISSUER_NAME" --home-region "$HOME_REGION" --validity Begin="$NOW" --entitlements "$ENTITLEMENTS" --beneficiary "$LICENSE_BENEFICIARY" --consumption-configuration RenewType="$CONSUMPTION_RENEW_TYPE",ProvisionalConfiguration={MaxTimeToLiveInMinutes=$CONSUMPTION_TTL} --client-token "$CLIENT_TOKEN" | jq -r ".LicenseArn" ) echo "License arn: $LICENSE_ARN" # Create Grant GRANT_TOKEN="e9a14140-4fca-4219-8230-57511a6ea6" GRANT_NAME="test-grant" GRANT_ARN=$(aws license-manager create-grant --grant-name "$GRANT_NAME" --license-arn "$LICENSE_ARN" --principals "$LICENSE_BENEFICIARY" --home-region "$HOME_REGION" --client-token "$GRANT_TOKEN" --allowed-operations "CheckoutLicense" "CheckInLicense" "ExtendConsumptionLicense" "CreateToken" | jq -r ".GrantArn") echo "Grant arn: $GRANT_ARN"
  2. Erstellen Sie ein Kubernetes-Secret mit dem Lizenz-Token und der IAM-Rolle und verwenden Sie dabei das zuvor definierte geheime Format. Verwenden Sie den License Manager CreateToken API-Vorgang, um ein Lizenztoken zu generieren. Verwenden Sie dann den CreateRole IAM-API-Vorgang, um eine IAM-Rolle mit Berechtigungen und einer Vertrauensrichtlinie zu erstellen. Sehen Sie sich das Beispiel im folgenden Skript an. Das folgende Skript verwendet Anmeldeinformationen für das Testkäuferkonto.

    read -p 'AWS Account for test license: ' TEST_ACCOUNT_ID read -p 'License Arn' LICENSE_ARN # Create IAM Role ROLE_NAME="AWSLicenseManagerConsumptionTestRole" ROLE_DESCRIPTION="Role to test AWS License Manager integration on-prem" ROLE_POLICY_ARN="arn:aws:iam::aws:policy/service-role/AWSLicenseManagerConsumptionPolicy" ROLE_TRUST_POLICY="{\"Version\": \"2012-10-17\",\"Statement\": [{ \"Effect\":\"Allow\", \"Principal\": { \"Federated\": \"openid-license-manager.amazonaws.com\" }, \"Action\": \"sts:AssumeRoleWithWebIdentity\",\"Condition\": { \"ForAnyValue:StringLike\": { \"openid-license-manager.amazonaws.com:amr\": \"aws:license-manager:token-issuer-account-id:${TEST_ACCOUNT_ID}\" }}}]}" ROLE_SESSION_DURATION=3600 ROLE_ARN=$(aws iam create-role --role-name "$ROLE_NAME" --description "$ROLE_DESCRIPTION" --assume-role-policy-document "$ROLE_TRUST_POLICY" --max-session-duration $ROLE_SESSION_DURATION | jq ".Role" | jq -r ".Arn") aws iam attach-role-policy --role-name "$ROLE_NAME" --policy-arn "$ROLE_POLICY_ARN" echo "Role arn: $ROLE_ARN" # Create Token CLIENT_TOKEN="b3920968-a94f-4547-af07-3dd232319367" TOKEN=$(aws license-manager create-token --license-arn $LICENSE_ARN --role-arns $ROLE_ARN --client-token $CLIENT_TOKEN | jq '.Token') echo "License access token: $TOKEN"c
  3. Richten Sie einen beliebigen Kubernetes-Cluster ein, der außerhalb gehostet wird. AWS Testen Sie damit, ob die Containeranwendungen von anderen Umgebungen aus eine Verbindung zur AWS License Manager API herstellen können AWS und ob der Anbieter für benutzerdefinierte Anmeldeinformationen gut in die Anwendung integriert ist.

  4. Stellen Sie das zuvor generierte Lizenz-Token und die IAM-Rolle im lokalen Kubernetes-Cluster bereit.

    kubectl create secret generic "awsmp-license-access-config" \ --from-literal=license_token=${TOKEN} \ --from-literal=iam_role=${ROLE_ARN}
  5. Stellen Sie Ihre Anwendung über Helm mit dem geheimen Namen als Eingabe bereit und stellen Sie sicher, dass die Anwendung License Manager Manager-API-Operationen aufrufen kann, um Berechtigungsprüfungen durchzuführen. Informationen zu Änderungen der Helm- und Bereitstellungsspezifikationen finden Sie in Integration eines AWS Marketplace for Containers Anywhere-Produkts mit License Manager Schritt 9 unter.

Testen der License Manager Manager-Integration auf Amazon EKS

Sie können die License Manager Manager-Integration auch auf Amazon EKS testen. Testen Sie, ob die Anwendung License Manager Manager-API-Operationen ohne den geheimen Lizenzkonfigurationsschlüssel aufrufen kann. Stellen Sie außerdem sicher, dass das Dienstkonto zur Einrichtung von IAM-Rollen für Dienstkonten (IRSA) und zur Bereitstellung relevanter Anmeldeinformationen für die Anwendung verwendet werden kann.

Um eine License Manager Manager-Integration auf Amazon EKS zu testen
  1. Erstellen Sie eine Testlizenz in einem Testverkäuferkonto mit den gewünschten Berechtigungen. Informationen zur Einrichtung Ihrer Testlizenz finden Sie in der CreateLicense API-Referenz oder verwenden Sie das folgende Skript, um eine Lizenz zu erstellen und einem Testkäuferkonto eine Lizenz zu gewähren, um die Lizenz zu nutzen. Das folgende Skript verwendet Anmeldeinformationen für das Testverkäuferkonto.

    read -p 'AWS Account for test buyer: ' TEST_BUYER_ACCOUNT_ID read -p 'License entitlements: ' ENTITLEMENTS # TEST_SELLER_ACCOUNT_ID="109876543210" # ENTITLEMENTS="{\"Name\": \"ByData\",\"MaxCount\": 1000,\"Overage\": true,\"Unit\": \"Gigabits\",\"AllowCheckIn\": true}" # Create License NOW=$(date +"%Y-%m-%dT00:00:00+00:00") PRODUCT_NAME="My awesome product" PRODUCT_SKU="c97b7825-44c4-4f42-b025-12baa4c171e0" LICENSE_BENEFICIARY=" arn:aws:iam::$TEST_BUYER_ACCOUNT_ID:root " LICENSE_ISSUER_NAME="test-seller" LICENSE_NAME="test-seller-license" CLIENT_TOKEN="b3920968-a94f-4547-af07-3dd232319367" CONSUMPTION_TTL=180 CONSUMPTION_RENEW_TYPE="None" HOME_REGION="us-east-1" LICENSE_ARN=$(aws license-manager create-license --license-name "$LICENSE_NAME" --product-name "$PRODUCT_NAME" --product-sku "$PRODUCT_SKU" --issuer Name="$LICENSE_ISSUER_NAME" --home-region "$HOME_REGION" --validity Begin="$NOW" --entitlements "$ENTITLEMENTS" --beneficiary "$LICENSE_BENEFICIARY" --consumption-configuration RenewType="$CONSUMPTION_RENEW_TYPE",ProvisionalConfiguration={MaxTimeToLiveInMinutes=$CONSUMPTION_TTL} --client-token "$CLIENT_TOKEN" | jq -r ".LicenseArn" ) echo "License arn: $LICENSE_ARN" # Create Grant GRANT_TOKEN="e9a14140-4fca-4219-8230-57511a6ea6" GRANT_NAME="test-grant" GRANT_ARN=$(aws license-manager create-grant --grant-name "$GRANT_NAME" --license-arn "$LICENSE_ARN" --principals "$LICENSE_BENEFICIARY" --home-region "$HOME_REGION" --client-token "$GRANT_TOKEN" --allowed-operations "CheckoutLicense" "CheckInLicense" "ExtendConsumptionLicense" "CreateToken" | jq -r ".GrantArn") echo "Grant arn: $GRANT_ARN"
  2. Erstellen Sie einen Amazon EKS-Testcluster mit den gewünschten Konfigurationen oder führen Sie die folgenden Befehle aus, um eine Standardkonfiguration zu verwenden.

    aws ec2 create-key-pair --region us-west-2 --key-name eks-key-pair
    eksctl create cluster \ --name awsmp-eks-test-example \ --region us-west-2 \ --with-oidc \ --ssh-access \ --ssh-public-key eks-key-pair
  3. Erstellen Sie ein Dienstkonto für einen vorhandenen Cluster und ordnen Sie ihn einer IAM-Rolle zu. Der folgende Befehl erstellt eine IAM-Rolle mit der. AWSLicenseManagerConsumptionPolicy Anschließend fügt der Befehl es dem test_sa Servicekonto des Amazon EKS-Clusters hinzu, auf dem die integrierten License Manager Manager-Images bereitgestellt werden sollen. Dadurch kann das Dienstkonto die entsprechenden Anmeldeinformationen für den Aufruf von License Manager Manager-API-Vorgängen abrufen.

    eksctl create iamserviceaccount \ --name test_sa \ --namespace test_namespace \ --cluster awsmp-eks-test-example \ --attach-policy-arn "arn:aws:iam::aws:policy/service-role/AWSLicenseManagerConsumptionPolicy" \ --approve \ --override-existing-serviceaccounts
  4. Stellen Sie die Anwendung über Helm in dem Dienstkonto bereit, dem die IAM-Rolle aus dem vorherigen Befehl zugeordnet ist. Stellen Sie sicher, dass die Anwendung License Manager Manager-API-Operationen aufrufen kann, um Berechtigungsprüfungen durchzuführen.

Flexible Lizenzberechtigungen mit License Manager

Bei Floating-Lizenzen wird, wenn sich Benutzer bei der Anwendung anmelden, eine Lizenz aus dem Pool verfügbarer Lizenzen abgerufen. Wenn sich Benutzer abmelden, werden die Lizenzen wieder dem Pool verfügbarer Lizenzen hinzugefügt.

Bei Floating-Lizenzen verwendet die Anwendung den CheckoutLicense API-Vorgang, um Berechtigungen aus dem Berechtigungspool auszuchecken, wenn die Ressource verwendet wird. Die Antwort auf den CheckoutLicense API-Vorgang beinhaltet ein Lizenzverbrauchstoken, das eine eindeutige Kennung für den Checkout darstellt. Mit dem Lizenzverbrauchstoken können zusätzliche Aktionen für die ausgecheckten Berechtigungen ausgeführt werden, z. B. sie wieder in den Lizenzpool eingecheckt oder das Auschecken verlängert werden.

Wenn die Ressource nicht mehr verwendet wird, verwendet die Anwendung den CheckInLicense API-Vorgang, um die Berechtigung wieder in den Pool einzuchecken.

aws license-manager check-in-license \ --license-consumption-token "f1603b3c1f574b7284db84a9e771ee12"

Wenn das erneute Einchecken einer Lizenz in den Pool fehlschlägt, z. B. wenn die Anwendung während des Vorgangs abstürzt, wird die Berechtigung nach 60 Minuten automatisch wieder in den Pool eingecheckt. Wenn die Ressource länger als 60 Minuten genutzt wird, ist es daher eine bewährte Methode, die Berechtigung aus dem Pool auszuchecken. Verwenden Sie dazu den ExtendLicenseConsumption API-Vorgang, solange die Ressource verwendet wird.

aws license-manager extend-license-consumption \ --license-consumption-token "f1603b3c1f574b7284db84a9e771ee12"

Bewährte Methoden für die Integration mit License Manager für lokale Bereitstellungen

Bei der Bereitstellung von Containeranwendungen in einer lokalen Umgebung kann es zu einem unzuverlässigen ausgehenden Netzwerkzugriff kommen. Verwenden Sie die folgenden bewährten Methoden, um die Ausfallsicherheit zu erhöhen und Serviceunterbrechungen für Käufer aufgrund potenzieller Probleme aufgrund schlechter Internetkonnektivität zu vermeiden:

  • Angemessener Wiederholungsversuch — Vorübergehende Netzwerkprobleme können dazu führen, dass Ihre Anwendung keine Verbindung zu Ihnen herstellt. AWS License Manager Implementieren Sie Wiederholungsversuche für bis zu 30 Minuten mit exponentiellem Back-up. Dies kann helfen, kurzfristige Ausfälle oder Netzwerkprobleme zu vermeiden.

  • Vermeiden Sie feste Grenzwerte — Anwendungen, die in verbundenen Clustern bereitgestellt werden, können Lizenzen regelmäßig überprüfen, um festzustellen, ob Änderungen aufgrund von Upgrades oder Verlängerungen vorgenommen wurden. Bei unzuverlässigem ausgehendem Zugriff ist die Anwendung möglicherweise nicht in der Lage, diese Änderungen zu erkennen. Wann immer möglich, sollte die Anwendung verhindern, dass der Service für Käufer unterbrochen wird, weil Lizenzen nicht über den License Manager überprüft werden können. Wenn die Lizenz abläuft, können Anwendungen auf eine kostenlose Testversion oder eine Open-Source-Version zurückgreifen und sie können nicht überprüfen, ob eine Lizenz gültig ist.

  • Kunden benachrichtigen — Wenn Sie eine zwischengespeicherte Lizenz verwenden, wirken sich Änderungen an der Lizenz (einschließlich Verlängerungen oder Upgrades) nicht automatisch auf den laufenden Workload aus. Informieren Sie Ihre Kunden (dass sie vorübergehend wieder ausgehenden Zugriff auf die Anwendung zulassen müssen), damit die Anwendung ihre zwischengespeicherte Lizenz aktualisieren kann. Informieren Sie Kunden beispielsweise über die Anwendung selbst oder über die zugehörige Dokumentation. Ebenso sollten Sie Kunden, wenn Sie auf einen niedrigeren Funktionsumfang zurückgreifen, darüber informieren, dass ihre Rechte erschöpft sind oder die Lizenz abgelaufen ist. Anschließend können sie wählen, ob sie ein Upgrade oder eine Verlängerung durchführen möchten.

LicenseManagerCredentialsProvider- Java-Implementierung

LicenseCredentialsProvidererweitert die standardmäßige Anbieterkette für Anmeldeinformationen des AWS SDK für die lokale Verwendung um Folgendes: LicenseManagerTokenCredentialsProvider

LicenseCredentialsProvider

package com.amazon.awsmp.license; import software.amazon.awssdk.auth.credentials.AwsCredentials; import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider; import software.amazon.awssdk.auth.credentials.AwsCredentialsProviderChain; import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider; import software.amazon.awssdk.auth.credentials.internal.LazyAwsCredentialsProvider; import software.amazon.awssdk.utils.SdkAutoCloseable; public class LicenseCredentialsProvider implements AwsCredentialsProvider, SdkAutoCloseable { private static final LicenseCredentialsProvider CREDENTIALS_PROVIDER = new LicenseCredentialsProvider(); private final LazyAwsCredentialsProvider providerChain; private LicenseCredentialsProvider() { this.providerChain = createChain(); } public static LicenseCredentialsProvider create() { return CREDENTIALS_PROVIDER; } @Override public AwsCredentials resolveCredentials() { return this.providerChain.resolveCredentials(); } @Override public void close() { this.providerChain.close(); } private LazyAwsCredentialsProvider createChain() { return LazyAwsCredentialsProvider.create(() -> { AwsCredentialsProvider[] credentialsProviders = new AwsCredentialsProvider[]{ DefaultCredentialsProvider.create(), LicenseManagerTokenCredentialsProvider.create()}; return AwsCredentialsProviderChain.builder().reuseLastProviderEnabled(true) .credentialsProviders(credentialsProviders).build(); }); } }

LicenseManagerTokenCredentialsProvider

LicenseManagerTokenCredentialsProviderstellt Anmeldeinformationen mithilfe von License Manager OIDC ausgestellten Identitätstoken in lokalen Umgebungen bereit. Sie müssen den Quellcode für LicenseCredentialsProvider in den Klassenpfad Ihrer Anwendung aufnehmen.

package com.amazon.awsmp.license; import software.amazon.awssdk.auth.credentials.AnonymousCredentialsProvider; import software.amazon.awssdk.auth.credentials.AwsCredentials; import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider; import software.amazon.awssdk.core.SdkSystemSetting; import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration; import software.amazon.awssdk.core.retry.RetryPolicyContext; import software.amazon.awssdk.core.retry.conditions.OrRetryCondition; import software.amazon.awssdk.core.retry.conditions.RetryCondition; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.regions.providers.DefaultAwsRegionProviderChain; import software.amazon.awssdk.services.licensemanager.LicenseManagerClient; import software.amazon.awssdk.services.licensemanager.model.GetAccessTokenRequest; import software.amazon.awssdk.services.licensemanager.model.GetAccessTokenResponse; import software.amazon.awssdk.services.sts.StsClient; import software.amazon.awssdk.services.sts.auth.StsAssumeRoleWithWebIdentityCredentialsProvider; import software.amazon.awssdk.services.sts.model.AssumeRoleWithWebIdentityRequest; import software.amazon.awssdk.services.sts.model.IdpCommunicationErrorException; import software.amazon.awssdk.utils.IoUtils; import software.amazon.awssdk.utils.SdkAutoCloseable; import software.amazon.awssdk.utils.StringUtils; import software.amazon.awssdk.utils.SystemSetting; import java.io.IOException; import java.io.InputStream; import java.io.UncheckedIOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.time.Duration; import java.util.function.Supplier; public class LicenseManagerTokenCredentialsProvider implements AwsCredentialsProvider, SdkAutoCloseable { private final StsAssumeRoleWithWebIdentityCredentialsProvider credentialsProvider; private final RuntimeException loadException; private Path licenseAccessTokenFile; private String roleArn; private String roleSessionName; private StsClient stsClient; private LicenseManagerClient lmClient; public static LicenseManagerTokenCredentialsProvider create() { return new Builder().build(); } @Override public AwsCredentials resolveCredentials() { if (this.loadException != null) { throw this.loadException; } return this.credentialsProvider.resolveCredentials(); } @Override public void close() { IoUtils.closeQuietly(this.credentialsProvider, null); IoUtils.closeQuietly(this.stsClient, null); IoUtils.closeIfCloseable(this.lmClient, null); } private LicenseManagerTokenCredentialsProvider(Builder builder) { StsAssumeRoleWithWebIdentityCredentialsProvider credentialsProvider = null; RuntimeException loadException = null; try { this.licenseAccessTokenFile = Paths.get(StringUtils.trim(LicenseSystemSetting.AWS_WEB_IDENTITY_REFRESH_TOKEN_FILE.getStringValueOrThrow())); this.roleArn = SdkSystemSetting.AWS_ROLE_ARN.getStringValueOrThrow(); this.roleSessionName = SdkSystemSetting.AWS_ROLE_SESSION_NAME.getStringValue().orElse("aws-sdk-java-" + System.currentTimeMillis()); this.stsClient = builder.stsClient != null ? builder.stsClient : StsClientFactory.create(); this.lmClient = builder.lmClient != null ? builder.lmClient : LicenseManagerClientFactory.create(); AssumeRoleWithWebIdentityRequest request = AssumeRoleWithWebIdentityRequest.builder() .roleArn(this.roleArn).roleSessionName(this.roleSessionName).build(); Supplier<AssumeRoleWithWebIdentityRequest> supplier = new AssumeRoleRequestSupplier(request, this.licenseAccessTokenFile, this.lmClient); credentialsProvider = StsAssumeRoleWithWebIdentityCredentialsProvider.builder() .stsClient(this.stsClient).refreshRequest(supplier).build(); } catch (RuntimeException ex) { loadException = ex; } this.credentialsProvider = credentialsProvider; this.loadException = loadException; } public static final class Builder { private Path licenseAccessTokenFile; private String roleArn; private String roleSessionName; private StsClient stsClient; private LicenseManagerClient lmClient; public LicenseManagerTokenCredentialsProvider build() { return new LicenseManagerTokenCredentialsProvider(this); } public LicenseManagerTokenCredentialsProvider.Builder licenseAccessTokenFile(Path licenseAccessTokenFile) { this.licenseAccessTokenFile = licenseAccessTokenFile; return this; } public LicenseManagerTokenCredentialsProvider.Builder roleArn(String roleArn) { this.roleArn = roleArn; return this; } public LicenseManagerTokenCredentialsProvider.Builder roleSessionName(String roleSessionName) { this.roleSessionName = roleSessionName; return this; } public LicenseManagerTokenCredentialsProvider.Builder stsClient(StsClient stsClient) { this.stsClient = stsClient; return this; } public LicenseManagerTokenCredentialsProvider.Builder lmClient(LicenseManagerClient lmClient) { this.lmClient = lmClient; return this; } } private static final class AssumeRoleRequestSupplier implements Supplier { private final LicenseManagerClient lmClient; private final AssumeRoleWithWebIdentityRequest request; private final Path webIdentityRefreshTokenFile; AssumeRoleRequestSupplier(final AssumeRoleWithWebIdentityRequest request, final Path webIdentityRefreshTokenFile, final LicenseManagerClient lmClient) { this.lmClient = lmClient; this.request = request; this.webIdentityRefreshTokenFile = webIdentityRefreshTokenFile; } public AssumeRoleWithWebIdentityRequest get() { return this.request.toBuilder() .webIdentityToken(getIdentityToken()) .build(); } private String getIdentityToken() { return refreshIdToken(readRefreshToken(this.webIdentityRefreshTokenFile)); } private String readRefreshToken(Path file) { try (InputStream webIdentityRefreshTokenStream = Files.newInputStream(file)) { return IoUtils.toUtf8String(webIdentityRefreshTokenStream); } catch (IOException e) { throw new UncheckedIOException(e); } } private String refreshIdToken(String licenseRefreshToken) { final GetAccessTokenRequest request = GetAccessTokenRequest.builder() .token(licenseRefreshToken) .build(); GetAccessTokenResponse response = this.lmClient.getAccessToken(request); return response.accessToken(); } } private static final class LicenseManagerClientFactory { private static final Duration DEFAULT_API_TIMEOUT = Duration.ofSeconds(30); private static final Duration DEFAULT_API_ATTEMPT_TIMEOUT = Duration.ofSeconds(10); public static LicenseManagerClient create() { return getLicenseManagerClient(); } private static LicenseManagerClient getLicenseManagerClient() { ClientOverrideConfiguration configuration = ClientOverrideConfiguration.builder() .apiCallTimeout(DEFAULT_API_TIMEOUT) .apiCallAttemptTimeout(DEFAULT_API_ATTEMPT_TIMEOUT) .build(); LicenseManagerClient client = LicenseManagerClient.builder() .region(configureLicenseManagerRegion()) .credentialsProvider(AnonymousCredentialsProvider.create()) .overrideConfiguration(configuration).build(); return client; } private static Region configureLicenseManagerRegion() { Region defaultRegion = Region.US_EAST_1; Region region; try { region = (new DefaultAwsRegionProviderChain()).getRegion(); } catch (RuntimeException ex) { region = defaultRegion; } return region; } } private static final class StsClientFactory { private static final Duration DEFAULT_API_TIMEOUT = Duration.ofSeconds(30); private static final Duration DEFAULT_API_ATTEMPT_TIMEOUT = Duration.ofSeconds(10); public static StsClient create() { return getStsClient(); } private static StsClient getStsClient() { OrRetryCondition retryCondition = OrRetryCondition.create(new StsRetryCondition(), RetryCondition.defaultRetryCondition()); ClientOverrideConfiguration configuration = ClientOverrideConfiguration.builder() .apiCallTimeout(DEFAULT_API_TIMEOUT) .apiCallAttemptTimeout(DEFAULT_API_ATTEMPT_TIMEOUT) .retryPolicy(r -> r.retryCondition(retryCondition)) .build(); return StsClient.builder() .region(configureStsRegion()) .credentialsProvider(AnonymousCredentialsProvider.create()) .overrideConfiguration(configuration).build(); } private static Region configureStsRegion() { Region defaultRegion = Region.US_EAST_1; Region stsRegion; try { stsRegion = (new DefaultAwsRegionProviderChain()).getRegion(); } catch (RuntimeException ex) { stsRegion = defaultRegion; } return stsRegion; } private static final class StsRetryCondition implements RetryCondition { public boolean shouldRetry(RetryPolicyContext context) { return context.exception() instanceof IdpCommunicationErrorException; } } } private enum LicenseSystemSetting implements SystemSetting { AWS_WEB_IDENTITY_REFRESH_TOKEN_FILE("aws.webIdentityRefreshTokenFile"); private String systemProperty; private String defaultValue = null; LicenseSystemSetting(String systemProperty) { this.systemProperty = systemProperty; } @Override public String property() { return this.systemProperty; } @Override public String environmentVariable() { return this.name(); } @Override public String defaultValue() { return this.defaultValue; } } }

LicenseManagerCredentialsProviderGolang- Implementierung

LicenseCredentialsProvider

LicenseCredentialsProvidererweitert die standardmäßige Anbieterkette für Anmeldeinformationen des AWS SDK für die lokale Verwendung um Folgendes: LicenseManagerTokenCredentialsProvider

package lib import ( "context" "fmt" "sync" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" ) // LicenseCredentialsProvider is the custom credential provider that can retrieve valid temporary aws credentials type LicenseCredentialsProvider struct { fallBackProvider aws.CredentialsProvider mux sync.RWMutex licenseCredentials aws.Credentials err error } // NewLicenseCredentialsProvider method will create a LicenseCredentialProvider Object which contains valid temporary aws credentials func NewLicenseCredentialsProvider() (*LicenseCredentialsProvider, error) { licenseCredentialProvider := &LicenseCredentialsProvider{} fallBackProvider, err := createCredentialProvider() if err != nil { return licenseCredentialProvider, fmt.Errorf("failed to create LicenseCredentialsProvider, %w", err) } licenseCredentialProvider.fallBackProvider = fallBackProvider return licenseCredentialProvider, nil } // Retrieve method will retrieve temporary aws credentials from the credential provider func (l *LicenseCredentialsProvider) Retrieve(ctx context.Context) (aws.Credentials, error) { l.mux.RLock() defer l.mux.RUnlock() l.licenseCredentials, l.err = l.fallBackProvider.Retrieve(ctx) return l.licenseCredentials, l.err } func createCredentialProvider() (aws.CredentialsProvider, error) { // LoadDefaultConfig will examine all "default" credential providers ctx := context.TODO() cfg, err := config.LoadDefaultConfig(ctx) if err != nil { return nil, fmt.Errorf("failed to create FallBackProvider, %w", err) } var useFallbackProvider bool if cfg.Credentials != nil { if _, err := cfg.Credentials.Retrieve(ctx); err != nil { // If the "default" credentials provider cannot retrieve credentials, enable fallback to customCredentialsProvider. useFallbackProvider = true } } else { useFallbackProvider = true } if useFallbackProvider { customProvider, err := newLicenseManagerTokenCredentialsProvider() if err != nil { return cfg.Credentials, fmt.Errorf("failed to create fallBackProvider, %w", err) } // wrap up customProvider with CredentialsCache to enable caching cfg.Credentials = aws.NewCredentialsCache(customProvider) } return cfg.Credentials, nil }

LicenseManagerTokenCredentialsProvider

LicenseManagerTokenCredentialsProviderstellt Anmeldeinformationen mithilfe von License Manager OIDC ausgestellten Identitätstoken in lokalen Umgebungen bereit. Sie müssen den Quellcode für LicenseCredentialsProvider in den Klassenpfad Ihrer Anwendung aufnehmen.

package lib import ( "context" "fmt" "io/ioutil" "os" "sync" "time" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/sts" ) const awsRefreshTokenFilePathEnvVar = "AWS_LICENSE_ACCESS_FILE" // licenseManagerTokenCredentialsProvider defines and contains StsAssumeRoleWithWebIdentityProvider type licenseManagerTokenCredentialsProvider struct { stsCredentialProvider *stsAssumeRoleWithWebIdentityProvider mux sync.RWMutex licenseCredentials aws.Credentials err error } // Retrieve method will retrieve credentials from credential provider. // Make this method public to make this provider satisfies CredentialProvider interface func (a *licenseManagerTokenCredentialsProvider) Retrieve(ctx context.Context) (aws.Credentials, error) { a.mux.RLock() defer a.mux.RUnlock() a.licenseCredentials, a.err = a.stsCredentialProvider.Retrieve(ctx) return a.licenseCredentials, a.err } // newLicenseManagerTokenCredentialsProvider will create and return a LicenseManagerTokenCredentialsProvider Object which wraps up stsAssumeRoleWithWebIdentityProvider func newLicenseManagerTokenCredentialsProvider() (*licenseManagerTokenCredentialsProvider, error) { // 1. Retrieve variables From yaml environment envConfig, err := config.NewEnvConfig() if err != nil { return &licenseManagerTokenCredentialsProvider{}, fmt.Errorf("failed to create LicenseManagerTokenCredentialsProvider, %w", err) } roleArn := envConfig.RoleARN var roleSessionName string if envConfig.RoleSessionName == "" { roleSessionName = fmt.Sprintf("aws-sdk-go-v2-%v", time.Now().UnixNano()) } else { roleSessionName = envConfig.RoleSessionName } tokenFilePath := os.Getenv(awsRefreshTokenFilePathEnvVar) b, err := ioutil.ReadFile(tokenFilePath) if err != nil { return &licenseManagerTokenCredentialsProvider{}, fmt.Errorf("failed to create LicenseManagerTokenCredentialsProvider, %w", err) } refreshToken := aws.String(string(b)) // 2. Create stsClient cfg, err := config.LoadDefaultConfig(context.TODO()) if err != nil { return &licenseManagerTokenCredentialsProvider{}, fmt.Errorf("failed to create LicenseManagerTokenCredentialsProvider, %w", err) } stsClient := sts.NewFromConfig(cfg, func(o *sts.Options) { o.Region = configureStsClientRegion(cfg.Region) o.Credentials = aws.AnonymousCredentials{} }) // 3. Configure StsAssumeRoleWithWebIdentityProvider stsCredentialProvider := newStsAssumeRoleWithWebIdentityProvider(stsClient, roleArn, roleSessionName, refreshToken) // 4. Build and return return &licenseManagerTokenCredentialsProvider{ stsCredentialProvider: stsCredentialProvider, }, nil } func configureStsClientRegion(configRegion string) string { defaultRegion := "us-east-1" if configRegion == "" { return defaultRegion } else { return configRegion } }