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. # Vertragspreise für Containerprodukte mit AWS License Manager Bei containerbasierten Produkten mit Vertragspreisen können Sie AWS License Manager Lizenzen mit Ihrem Produkt verknüpfen. AWS License Manager ist ein Lizenzverwaltungstool, mit dem Ihre Anwendung Lizenzen (auch als Berechtigungen bezeichnet), die von einem Kunden gekauft wurden, verfolgen und aktualisieren kann. Dieser Abschnitt enthält Informationen darüber, wie Sie Ihr Produkt in integrieren können. AWS License Manager Nach Abschluss der Integration können Sie Ihre Produktliste am veröffentlichen AWS Marketplace. Wenn Sie License Manager in ein AWS Marketplace for Containers Anywhere-Produkt für Amazon EKS Anywhere, Amazon ECS Anywhere, Amazon Elastic Compute Cloud (Amazon EC2) oder eine lokale Infrastruktur integrieren, folgen Sie den Anweisungen unter. [Integration von an AWS Marketplace for Containers Anywhere mit License Manager](container-anywhere-license-manager-integration.md) Weitere Informationen zu AWS License Manager finden Sie im [AWS License Manager Benutzerhandbuch](https://docs.aws.amazon.com/license-manager/latest/userguide/license-manager.html) und im [AWS License Manager](https://docs.aws.amazon.com/cli/latest/reference/license-manager/index.html)Abschnitt der *AWS CLI Befehlsreferenz*. Weitere Informationen zur Integration von AWS License Manager Container-Produkten mit Vertragspreisen finden Sie im Labor „[Integration mit Vorauszahlung](https://catalog.workshops.aws/mpseller/en-US/container/integrate-contract)“ des *AWS Marketplace Verkäuferworkshops*. **Topics** + [Vertragspreise für Containerprodukte](#container-contracts) + [Lizenzmodelle](#container-LM-license-models) + [AWS License Manager Voraussetzungen für die Integration](#container-LM-prereqs) + [Integration eines Containerprodukts mit License Manager](#container-integrate-with-LM) + [License Manager Manager-API-Operationen](#container-LM-API-calls) + [Verlängerungen und Upgrades von Lizenzen](#container-LM-lic-renew-upgrade) + [Integration von an AWS Marketplace for Containers Anywhere mit License Manager](container-anywhere-license-manager-integration.md) ## Vertragspreise für Containerprodukte Bei Produkten auf Containerbasis mit Vertragspreisen stellen Sie Ihren Kunden die AWS Marketplace Rechnung im Voraus oder nach dem von Ihnen festgelegten Zahlungsplan auf der Grundlage des Vertrags zwischen Ihnen und Ihrem Kunden in Rechnung. Ab diesem Zeitpunkt sind sie berechtigt, die Ressourcen zu nutzen. Um Ihre Preise festzulegen, wählen Sie eine oder mehrere Vertragslaufzeiten, die Sie Ihren Kunden anbieten. Sie können für jede Vertragslaufzeit unterschiedliche Preise eingeben. Sie haben die Wahl zwischen 1 Monat, 12 Monaten, 24 Monaten und 36 Monaten. Für private Angebote können Sie eine benutzerdefinierte Dauer in Monaten (bis zu 60 Monaten) angeben. Wählen Sie die Kategorie, die der Preisgestaltung Ihres Produkts am besten entspricht. Die Preiskategorie wird Kunden auf der AWS Marketplace Website angezeigt. Sie können zwischen **Bandbreite** (GB/s, MB/s), **Daten** (GB, MB, TB), **Hosts**, **Anfragen**, **Stufen** oder **Benutzern** wählen. Wenn keine der vordefinierten Kategorien Ihren Anforderungen entspricht, können Sie die allgemeinere Kategorie **Einheiten** wählen. Das Angebot ermöglicht das Hinzufügen von bis zu 24 Dimensionen. **Beispiel: Anwendung zur Datenspeicherung** | | Preis für 1 Monat | Preis für 12 Monate | Preis für 24 Monate | Preis für P36 Monate | | --- | --- | --- | --- | --- | | Unverschlüsselte Daten (GB) | 1,50 USD/GB | 16,00 USD/GB | 30,00 USD/GB | 60,00 USD/GB | | Verschlüsselte Daten (GB) | 1,55 USD/GB | 16,60 USD/GB | 31,20 USD/GB | 61,20 USD/GB | **Beispiel: Produkt zur Protokollüberwachung** | | Preis für 1 Monat | Preis für 12 Monate | Preis für 24 Monate | Preis für 36 Monate | | --- | --- | --- | --- | --- | | Basic (10 überwachte Hosts, 5 überwachte Container) | 100 USD | 1000 USD | 2000 USD | 4000 USD | | Standard (20 überwachte Hosts, 10 überwachte Container) | 200 USD | 2000 USD | 4000 USD | 8000\$1 | | Pro (40 überwachte Hosts, 20 überwachte Container) | 400 USD | 4000 USD | 8000\$1 | 16.000\$1 | | Zusätzliche überwachte Hosts pro Stunde | 10\$1 | 100 USD | 200 USD | 400 USD | | Zusätzliche überwachte Container pro Stunde | 10\$1 | 100 USD | 200 USD | 400 USD | **Anmerkung** Die Preise können für 1 Monat, 12 Monate, 24 Monate oder 36 Monate festgelegt werden. Sie können eine oder mehrere dieser Optionen für Ihr Produkt anbieten. Die Dauer muss für jede Dimension gleich sein. **Example** Wenn Sie beispielsweise `AdminUsers` Abmessungen angeben `ReadOnlyUsers` und einen Jahrespreis für anbieten ReadOnlyUsers, müssen Sie auch einen Jahrespreis für `AdminUsers` angeben. ### Automatische Verlängerung Wenn Kunden Ihr Produkt im Rahmen AWS Marketplace von Container-Verträgen kaufen, können sie sich darauf einigen, die Vertragsbedingungen automatisch zu verlängern. Die Kunden zahlen weiterhin jeden Monat oder für 1, 2 oder 3 Jahre für die Nutzungsrechte. Kunden können ihre Verlängerungseinstellungen jederzeit ändern. Weitere Informationen finden Sie im *AWS Marketplace Buyer Guide* unter [Einen bestehenden Vertrag ändern](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-container-contracts.html#modify-existing-contract). ## Lizenzmodelle AWS Marketplace Integration mit AWS License Manager unterstützt zwei Lizenzmodelle: + [Konfigurierbares Lizenzmodell](#container-LM-config-lic-model) + [Gestaffeltes Lizenzmodell](#container-LM-tiered-lic-model) ### Konfigurierbares Lizenzmodell Das konfigurierbare Lizenzmodell (auch als quantifizierbares Lizenzmodell bezeichnet) berechtigt einen Käufer zu einer bestimmten Menge an Ressourcen, nachdem er eine Lizenz erworben hat. Sie legen eine Preisdimension und einen Preis pro Einheit fest. Anschließend kann der Käufer die Menge der Ressourcen wählen, die er kaufen möchte. **Example nach Preisdimension und Preis pro Einheit** Sie können eine Preisdimension (z. B. Datensicherung) und einen Preis pro Einheit (z. B. 30 USD/Einheit) festlegen. Der Käufer kann wählen, ob er 5, 10 oder 20 Einheiten kaufen möchte. Ihr Produkt verfolgt und misst den Verbrauch, um die Menge der verbrauchten Ressourcen zu messen. Beim Konfigurationsmodell werden die Berechtigungen auf eine von zwei Arten gezählt: + [Drawdown-Lizenzen](#container-floating-lic) + [Floating-Lizenzen](#container-floating-lic) #### Drawdown-Lizenz Die Lizenz wird bei der Nutzung aus dem Pool der zulässigen Anzahl an Lizenzen entnommen. Diese Berechtigung ist dauerhaft ausgecheckt und kann nicht wieder in den Lizenzpool aufgenommen werden. **Example der Verarbeitung einer begrenzten Datenmenge** Ein Benutzer ist berechtigt, 500 GB Daten zu verarbeiten. Während sie weiterhin Daten verarbeiten, wird die Menge aus dem Pool von 500 GB entnommen, bis alle 500-GB-Lizenzen aufgebraucht sind. Bei Drawdown-Lizenzen können Sie den `CheckoutLicense` API-Vorgang verwenden, um verbrauchte Lizenzeinheiten (Berechtigungen) auszuchecken. **Example von Backups auf Amazon S3 für eine Reihe von Einheiten/Jahr** Sie haben ein Speicherprodukt, das die Sicherung von bis zu 1.024 Dateneinheiten auf Amazon Simple Storage Service für ein Jahr ermöglicht. Ihre Anwendung kann mithilfe mehrerer Amazon EC2 EC2-Instances gestartet werden. Ihre Anwendung verfügt über einen Mechanismus zum Verfolgen und Aggregieren von Daten. Ihre Software ruft den `CheckoutLicense` API-Vorgang mit der Produkt-ID bei jedem Backup oder in festen Intervallen auf, um die verbrauchten Mengen zu aktualisieren. In diesem Beispiel ruft Ihre Software den `CheckoutLicense` API-Vorgang auf, um 10 Dateneinheiten auszuchecken. Wenn die Gesamtkapazität das vom Kunden gekaufte Backup-Limit erreicht, schlägt der API-Aufruf fehl. **Anforderung** ``` linux-machine ~]$ aws license-manager checkout-license\ --product-sku "2205b290-19e6-4c76-9eea-377d6bf7la47" \ --checkout-type "PERPETUAL" \ --key-fingerprint "aws:294406891311:AWS/Marketplace:issuer-fingerprint" \ --entitlements "Name=DataConsumption, Value=l0, Unit=Count" \ --client-token "AKIAIOSFODNN7EXAMPLE" ``` **Antwort** ``` {"CheckoutType": "PERPETUAL", "EntitlementsAllowed": [{ "Name": "IntermediateTier", "Units": "None" }], "Expiration": "2021-04-22Tl9:02:36", "IssuedAt": "2021-04-22Tl8:02:36", "LicenseArn": "arn:aws:license-manager::294406891311:license:l-16bf01b...", "LicenseConsumptionToken": "AKIAIOSFODNN7EXAMPLE" } ``` #### Flexible Lizenzen Die Lizenz wird nach der Verwendung wieder in den Pool mit der zulässigen Anzahl an Lizenzen zurückgeführt. Bei Floating-Lizenzen checkt die Anwendung die Berechtigungen aus dem Berechtigungspool mithilfe der `CheckoutLicense` API-Operation aus, wenn die Ressource verwendet wird. Die Antwort auf den `CheckoutLicense` API-Vorgang beinhaltet ein Lizenzverbrauchstoken, das eine eindeutige Kennung für den Checkout darstellt. Das Lizenzverbrauchstoken kann verwendet werden, um zusätzliche Aktionen an den ausgecheckten Berechtigungen durchzuführen, z. B. sie wieder in die Lizenz einzuchecken oder den Checkout zu verlängern. Um die Berechtigung wieder in den Pool einzuchecken, verwenden Sie den `CheckInLicense` API-Vorgang, wenn die Ressource nicht mehr verwendet wird. ``` aws license-manager check-in-license --license-consumption-token "f1603b3c1f574b7284db84..." ``` Falls die Berechtigung nicht eingecheckt werden kann (falls die Anwendung abgestürzt ist), wird die Berechtigung nach 60 Minuten automatisch wieder in den Pool eingecheckt. Wenn die Ressource länger als 60 Minuten genutzt wird, empfiehlt es sich, die Berechtigung mithilfe des `ExtendLicenseConsumption` API-Vorgangs aus dem Pool auszuchecken, solange die Ressource genutzt wird. ``` aws license-manager extend-license-consumption --license-consumption-token "f1603b3c1f574b7284..." ``` **Example von der Anzahl der Benutzer ab einer festen Obergrenze** Ein Benutzer hat Anspruch auf 500 gleichzeitige Benutzer in der Anwendung. Wenn sich Benutzer an- und abmelden, werden die Benutzer gezogen und wieder dem Pool von 500 Benutzern zugewiesen. Die Anwendung kann jedoch nicht mehr als 500 Benutzer aus dem Pool ziehen, da 500 gleichzeitige Benutzer die feste Obergrenze sind. Bei variablen Berechtigungen können Sie den `CheckInLicense` API-Vorgang verwenden, um die Lizenzeinheiten an den Berechtigungspool zurückzugeben. **Example der Anzahl gleichzeitiger Benutzer für ein Jahr** Der Preis Ihres Produkts basiert auf der Anzahl der gleichzeitigen Benutzer. Der Kunde erwirbt eine Lizenz für 10 Benutzer für ein Jahr. Der Kunde startet die Software, indem er AWS Identity and Access Management (IAM-) Berechtigungen erteilt. Wenn sich ein Benutzer anmeldet, ruft Ihre Anwendung den `CheckoutLicense` API-Vorgang auf, um die Menge um 1 zu reduzieren. Wenn sich der Benutzer abmeldet, gibt die Anwendung diese Lizenz an den Pool zurück, indem sie den `CheckInLicense` API-Vorgang aufruft. Wenn Sie nicht anrufen`CheckInLicense`, wird die Lizenzeinheit nach 1 Stunde automatisch eingecheckt. **Anmerkung** In der folgenden Anfrage handelt es sich `key-fingerprint` nicht um einen Platzhalterwert, sondern um den tatsächlichen Wert des Fingerabdrucks, mit dem alle Lizenzen veröffentlicht werden. **Anforderung** ``` aws license-manager checkout-license\ --product-sku "2205b290-19e6-4c76-9eea-377d6bf7la47" \ --checkout-type "PROVISIONAL" \ --key-fingerprint "aws:294406891311:AWS/Marketplace:issuer-fingerprint" \ --entitlements "Name=ReadOnlyUSers, Value=l0, Unit=Count" \ --client-token "AKIAIOSFODNN7EXAMPLE" ``` **Antwort** ``` { "CheckoutType": "PROVISIONAL", "EntitlementsAllowed": [ { "Name": "ReadOnlyUsers", "Count": 10, "Units": "Count", "Value": "Enabled" } }, "Expiration": "2021-04-22Tl9:02: 36", "IssuedAt": "2021-04-22Tl8:02:36", "LicenseArn": "arn:aws:license-manager::294406891311:license:l-16bf01b...", "LicenseConsumptionToken": "AKIAIOSFODNN7EXAMPLE" } ``` ### Gestaffeltes Lizenzmodell Das gestaffelte Lizenzmodell berechtigt einen Käufer, eine bestimmte Stufe oder Stufe von Anwendungsfunktionen zu nutzen, nachdem der Käufer eine Lizenz erworben hat. Sie erstellen Stufen für Ihr Produkt, z. B. Basic, Intermediate und Premium. Der Käufer wählt dann eine der vordefinierten Stufen aus. Die Anwendung muss die Nutzung der Anwendung nicht verfolgen oder messen. Beim abgestuften Lizenzmodell werden die Berechtigungen nicht mitgezählt, sondern stehen für eine vom Kunden bereitgestellte Servicestufe. Wenn Sie gebündelte Funktionen anbieten möchten, sind Stufen vorzuziehen. **Example der Stufen Basic, Intermediate und Premium** Ein Kunde kann einen Vertrag für eine von drei möglichen Stufen der Software unterzeichnen: Basic, Intermediate oder Premium. Jede dieser Stufen hat ihre eigenen Preise. Ihre Software kann die Stufe identifizieren, für die sich der Kunde angemeldet hat, indem sie den `CheckoutLicense` API-Vorgang aufruft und alle möglichen Stufen in der Anfrage angibt. Die Antwort auf die Anfrage enthält den Anspruch, der der Stufe entspricht, die der Kunde erworben hat. Auf der Grundlage dieser Informationen kann die Software das entsprechende Kundenerlebnis bieten. #### Anforderung ``` linux-machine ~]$ aws license-manager checkout-license\ --product-sku "2205b290-19e6-4c76-9eea-377d6bf7la47" \ --checkout-type "PROVISIONAL" \ --key-fingerprint "aws:294406891311:AWS/Marketplace:issuer-fingerprint" \ --entitlements "Name=BasicTier, Unit=None" "Name=IntermediateTier, Unit=None" \ "Name=PremiumTier, Unit=None" ``` #### Antwort ``` { "CheckoutType": "PROVISIONAL", "EntitlementsAllowed": [ { "Name": "IntermediateTier", "Units": "None" } }, "Expiration": "2021-04-22Tl9:02:36", "IssuedAt": "2021-04-22Tl8:02:36", "LicenseArn": "arn:aws:license-manager::294406891311:license:l-16bf01b...", "LicenseConsumptionToken": "AKIAIOSFODNN7EXAMPLE" } ``` ## AWS License Manager Voraussetzungen für die Integration Bevor Sie das Produkt veröffentlichen, müssen Sie Folgendes tun: 1. Erstellen Sie ein neues Containerprodukt in der AWS Marketplace Management Portal und notieren Sie sich den zugehörigen Produktcode. Weitere Informationen finden Sie unter [Überblick: Erstellen Sie ein Container-Produkt](container-product-getting-started.md#create-container-product). 1. Verwenden Sie eine IAM-Rolle für die Aufgabe oder den Pod, auf dem Ihre Anwendung ausgeführt wird, mit den IAM-Berechtigungen, die zum Aufrufen der `CheckoutLicense` `CheckInLicense` API-Operationen`ExtendLicenseConsumption`, und erforderlich sind. Die erforderlichen IAM-Berechtigungen werden in der folgenden IAM-Richtlinie detailliert beschrieben. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid":"VisualEditorO", "Effect":"Allow", "Action":[ "license-manager:CheckoutLicense", "license-manager:GetLicense", "license-manager:CheckInLicense", "license-manager:ExtendLicenseConsumption", "license-manager:ListReceivedLicenses" ], "Resource":"*" } ] } ``` ------ 1. Führen Sie einen Testaufruf für den `RegisterUsage` API-Vorgang mit einem Datensatz für alle von Ihnen definierten Preisdimensionen durch. ## Integration eines Containerprodukts mit License Manager **Um Ihr containerbasiertes Produkt mit License Manager zu integrieren** 1. Legen Sie die IAM-Berechtigungen fest, um License Manager aufzurufen. Weitere Informationen finden Sie unter [AWS License Manager Voraussetzungen für die Integration](#container-LM-prereqs). 1. Laden Sie das AWS SDK herunter. **Anmerkung** Konfigurieren Sie keine AWS Anmeldeinformationen in Ihrer Software. AWS Anmeldeinformationen für den Käufer werden automatisch zur Laufzeit abgerufen, wenn Ihr Container in einer Amazon EC2-Instance, einer Amazon ECS-Aufgabe oder einem Amazon EKS-Pod ausgeführt wird. 1. Fügen Sie Ihrem Produkt Lizenzprüfungen hinzu. Ihr Produkt kann den `CheckoutLicense` API-Vorgang überall dort aufrufen, wo die Lizenzprüfung durchgeführt werden soll. Um die Lizenz zu überprüfen, muss Ihr Produkt Folgendes wissen: 1. Der vertrauenswürdige Aussteller der Lizenz ()AWS Marketplace 1. Die Produkt-SKU (Produkt-ID) der Anwendung 1. Das Recht, nach dieser Anwendung zu suchen Die API-Aufrufe variieren je nachdem, welche Preislizenzen Sie einrichten. 1. Veröffentlichen Sie Ihre Produktliste am AWS Marketplace. ## License Manager Manager-API-Operationen Um die im License Manager-Konto des Kunden gespeicherten Lizenzen zu verwalten, kann Ihre Software die folgenden API-Operationen verwenden: + `GetLicense`— Eine API, die die Software abfragen kann. Es ruft den Status einer gekauften Lizenz ab (d. h. abgelaufen oder läuft bald ab) und sendet eine Statusbenachrichtigung an den Kunden. + `CheckoutLicense`— Erkennt Lizenzen, die der Benutzer gekauft hat. Sie können den `CheckoutLicense` API-Vorgang auch verwenden, um die Lizenzmenge zu aktualisieren, wenn der Benutzer eine bestimmte Anzahl von Lizenzen verbraucht hat. Mit `CheckoutLicense` können Sie immer wieder die Anzahl der vom Kunden verwendeten Lizenzen überprüfen. Wenn der Kunde alle Lizenzen aufgebraucht hat, gibt dieser Aufruf einen Fehler zurück. Informationen zur empfohlenen Schrittfrequenz finden Sie `CheckoutLicense` unter. [Verlängerungen und Upgrades von Lizenzen](#container-LM-lic-renew-upgrade) + `ExtendLicenseConsumption`— Bei variablen Dimensionen wird die Lizenz beim Auschecken einer Lizenz durch die Software nach 60 Minuten automatisch wieder in den Pool aufgenommen. Wenn Sie die Zeit verlängern möchten, für die die Lizenz ausgecheckt bleibt, verwenden Sie den `ExtendLicenseConsumption` API-Vorgang, um die Lizenz um weitere 60 Minuten zu verlängern. + `CheckInLicense`— Wenn Sie bei variablen Dimensionen die Lizenz an den Berechtigungspool zurückgeben möchten, verwenden Sie den `CheckInLicense` API-Vorgang. + `ListReceivedLicenses`API — Listet die vom Käufer gekauften Lizenzen auf. ## Verlängerungen und Upgrades von Lizenzen Kunden können ihre Lizenzen auf der verlängern oder aktualisieren. AWS Marketplace Management Portal AWS Marketplace Generiert nach einem zusätzlichen Kauf eine neue Version der Lizenz, die die neuen Rechte widerspiegelt. Ihre Software liest die neuen Berechtigungen mithilfe derselben API-Operationen. Sie müssen bei der License Manager Manager-Integration nichts anderes tun, um Verlängerungen und Upgrades abzuwickeln. Aufgrund von Lizenzverlängerungen, Upgrades, Stornierungen usw. empfehlen wir, dass Ihr Produkt den `CheckoutLicense` API-Vorgang in regelmäßigen Abständen aufruft, während das Produkt verwendet wird. Durch die regelmäßige Nutzung des `CheckoutLicense` API-Vorgangs kann das Produkt Änderungen an Berechtigungen erkennen, z. B. Upgrades und deren Ablauf. Wir empfehlen, den `CheckoutLicense` API-Aufruf alle 15 Minuten durchzuführen. # 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, Amazon EC2 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 unter[Vertragspreise für Containerprodukte mit AWS License Manager](container-license-manager-integration.md). Weitere Informationen AWS License Manager dazu finden Sie im [AWS License Manager Benutzerhandbuch](https://docs.aws.amazon.com/license-manager/latest/userguide/license-manager.html) und im [AWS License Manager](https://docs.aws.amazon.com/cli/latest/reference/license-manager/index.html)Abschnitt der *AWS CLI Befehlsreferenz*. **Topics** + [Integration eines AWS Marketplace for Containers Anywhere-Produkts mit License Manager](#containers-anywhere-integrate-with-LM) + [Die License Manager Manager-Integration lokal testen](#container-testing-LM-integration-locally) + [Testen der License Manager Manager-Integration auf Amazon EKS](#container-testing-LM-integration-EKS) + [Flexible Lizenzberechtigungen mit License Manager](#container-LM-floating-license) + [Bewährte Methoden für die Integration mit License Manager für lokale Bereitstellungen](#container-LM-best-practices-on-prem) + [`LicenseManagerCredentialsProvider`- Java-Implementierung](#container-license-manager-cred-provider-java) + [`LicenseManagerCredentialsProvider``Golang`- Implementierung](#container-license-manager-cred-provider-golang) ## 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](https://aws.amazon.com/marketplace/management/) an. 1. 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**. 1. Geben Sie einen kundenorientierten Namen für Ihr Produkt ein und wählen Sie **Create**. Sie können diesen Namen später ändern. 1. 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. 1. 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](https://aws.amazon.com/tools/). **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](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts-minimum-sdk.html). 1. 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: + [`LicenseManagerCredentialsProvider`- Java-Implementierung](#container-license-manager-cred-provider-java) + [`LicenseManagerCredentialsProvider``Golang`- Implementierung](#container-license-manager-cred-provider-golang) `LicenseCredentialsProvider`erweitert 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** `DefaultCredentialsProvider`Durch 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()); ``` 1. 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` oder`PERPETUAL`: + Verwenden Sie diese Option`PERPETUAL`, 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 unter[Flexible Lizenzberechtigungen mit License Manager](#container-LM-floating-license). + `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": "", "Unit": "None" } ``` + Geben Sie für gezählte Berechtigungen die `Count` Eigenschaften `Name``Unit`, und wie folgt an. ``` { "Name": "", "Unit": "", "Value": } ``` + `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](#container-LM-best-practices-on-prem). 1. 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](#container-LM-best-practices-on-prem). 1. Nachdem Sie den `CheckoutLicense` Aufruf in Ihre Container-Anwendung integriert haben, erstellen Sie eine neue Version Ihres Docker-Container-Images mit den Änderungen. 1. 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: // License Manager issued JWT token iam_role: // AWS Identity and Access Management role to assume with license token ``` 1. 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](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) 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. 1. 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](#container-testing-LM-integration-locally) 1. [Testen der License Manager Manager-Integration auf Amazon EKS](#container-testing-LM-integration-EKS) 1. 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](container-product-getting-started.md#create-container-product) ## 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 [CreateLicense](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_CreateLicense.html)in 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" ``` 1. 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 ``` 1. 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. 1. 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} ``` 1. 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](#containers-anywhere-integrate-with-LM) 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](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_CreateLicense.html) 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" ``` 1. 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 ``` 1. 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 ``` 1. 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 `LicenseCredentialsProvider`erweitert 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`** `LicenseManagerTokenCredentialsProvider`stellt 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 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; } } } ``` ## `LicenseManagerCredentialsProvider``Golang`- Implementierung **`LicenseCredentialsProvider`** `LicenseCredentialsProvider`erweitert 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`** `LicenseManagerTokenCredentialsProvider`stellt 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 } } ```