Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Prezzi contrattuali per prodotti in container con AWS License Manager Per i prodotti basati su container con prezzi contrattuali, puoi usarli AWS License Manager per associare le licenze al tuo prodotto. AWS License Manager è uno strumento di gestione delle licenze che consente all'applicazione di tenere traccia e aggiornare le licenze (note anche come autorizzazioni) acquistate da un cliente. Questa sezione fornisce informazioni su come integrare il prodotto con. AWS License Manager Una volta completata l'integrazione, puoi pubblicare la tua scheda di prodotto su Marketplace AWS. Se stai integrando License Manager con un prodotto Marketplace AWS for Containers Anywhere per Amazon EKS Anywhere, Amazon ECS Anywhere, Amazon Elastic Compute Cloud (Amazon EC2) Elastic Compute Cloud (Amazon EC2) o un'infrastruttura locale, segui le istruzioni riportate in. [Integrazione di an Marketplace AWS for Containers Anywhere con License Manager](container-anywhere-license-manager-integration.md) *Per ulteriori informazioni in merito AWS License Manager, consulta la [Guida per l'AWS License Manager utente e la [AWS License Manager](https://docs.aws.amazon.com/cli/latest/reference/license-manager/index.html)sezione del Command](https://docs.aws.amazon.com/license-manager/latest/userguide/license-manager.html) Reference.AWS CLI * Per ulteriori informazioni sull'integrazione AWS License Manager con i prodotti container con prezzi contrattuali, consulta il laboratorio [Integrazione con pagamento anticipato](https://catalog.workshops.aws/mpseller/en-US/container/integrate-contract) del workshop per i *Marketplace AWS venditori*. **Topics** + [Prezzi contrattuali per i prodotti in container](#container-contracts) + [Modelli di licenza](#container-LM-license-models) + [AWS License Manager prerequisiti di integrazione](#container-LM-prereqs) + [Integrazione di un prodotto contenitore con License Manager](#container-integrate-with-LM) + [Operazioni dell'API License Manager](#container-LM-API-calls) + [Rinnovi e aggiornamenti delle licenze](#container-LM-lic-renew-upgrade) + [Integrazione di an Marketplace AWS for Containers Anywhere con License Manager](container-anywhere-license-manager-integration.md) ## Prezzi contrattuali per i prodotti in container Per i prodotti basati su container con prezzi contrattuali, Marketplace AWS fattura i clienti in anticipo o in base al piano di pagamento da te definito, in base al contratto tra te e il cliente. Dopo quel punto, hanno il diritto di utilizzare tali risorse. Per impostare i prezzi, scegli una o più durate contrattuali che offri ai clienti. Puoi inserire prezzi diversi per ogni durata del contratto. Le opzioni disponibili sono durate di 1 mese, 12 mesi, 24 mesi e 36 mesi. Per le offerte private, puoi specificare una durata personalizzata in mesi (fino a 60 mesi). Scegli la categoria che meglio descrive il prezzo del tuo prodotto. La categoria di prezzo viene visualizzata dai clienti sul Marketplace AWS sito web. **Puoi scegliere tra **larghezza di banda** (GB/s, MB/s), **dati** (GB, MB, TB), **host**, **richieste**, **livelli** o utenti.** **Se nessuna delle categorie predefinite soddisfa le tue esigenze, puoi scegliere la categoria più generica di Unità.** L'offerta consente di aggiungere fino a 24 dimensioni. **Esempio: applicazione di archiviazione dati** | | Prezzo per 1 mese | Prezzo per 12 mesi | Prezzo per 24 mesi | Prezzo per 36 mesi | | --- | --- | --- | --- | --- | | Dati non crittografati (GB) | 1,50 USD/GB | \$116,00/GB | \$130,00/GB | \$160,00/GB | | Dati crittografati (GB) | 1,55 USD/GB | \$116,60/GB | \$131,20/GB | \$161,20/GB | **Esempio: prodotto per il monitoraggio dei log** | | Prezzo per 1 mese | Prezzo per 12 mesi | Prezzo per 24 mesi | Prezzo per 36 mesi | | --- | --- | --- | --- | --- | | Base (10 host monitorati, 5 container monitorati) | \$1100 | \$11000 | 2000 dollari | 4000 dollari | | Standard (20 host monitorati, 10 container monitorati) | \$1200 | 2000\$1 | 4000 dollari | 8000 dollari | | Pro (40 host monitorati, 20 container monitorati) | 400 dollari | 4000 dollari | 8000 dollari | 16.000\$1 | | Host aggiuntivi monitorati ogni ora | \$110 | \$1100 | \$1200 | 400 dollari | | Contenitori aggiuntivi monitorati ogni ora | \$110 | \$1100 | \$1200 | 400 dollari | **Nota** I prezzi possono essere per le seguenti durate: 1 mese, 12 mesi, 24 mesi o 36 mesi. Puoi scegliere di offrire una o più di queste opzioni per il tuo prodotto. Le durate devono essere le stesse in ogni dimensione. **Example** Ad esempio, nel caso in cui tu abbia `ReadOnlyUsers` delle `AdminUsers` dimensioni, se offri un prezzo annuale per ReadOnlyUsers, devi offrire anche un prezzo annuale per`AdminUsers`. ### Rinnovi automatici Quando i clienti acquistano il prodotto Marketplace AWS utilizzando contratti relativi ai container, possono accettare di rinnovare automaticamente i termini del contratto. I clienti continuano a pagare i diritti ogni mese o per 1, 2 o 3 anni. I clienti possono modificare le impostazioni di rinnovo in qualsiasi momento. Per ulteriori informazioni, consulta [Modifica di un contratto esistente](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-container-contracts.html#modify-existing-contract) nella *Guida all'Marketplace AWS acquisto*. ## Modelli di licenza Marketplace AWS integrazione con AWS License Manager supporta due modelli di licenza: + [Modello di licenza configurabile](#container-LM-config-lic-model) + [Modello di licenza a più livelli](#container-LM-tiered-lic-model) ### Modello di licenza configurabile Il modello di licenza configurabile (noto anche come modello di licenza quantificabile) dà diritto a un acquirente a una quantità specifica di risorse dopo che l'acquirente si è procurato una licenza. Hai impostato una dimensione di prezzo e un prezzo unitario. L'acquirente può quindi scegliere la quantità di risorse che desidera acquistare. **Example della dimensione dei prezzi e del prezzo unitario** Puoi impostare una dimensione di prezzo (come il backup dei dati) e un prezzo unitario (ad esempio 30 USD per unità). L'acquirente può scegliere di acquistare 5, 10 o 20 unità. Il prodotto monitora e misura l'utilizzo per misurare la quantità di risorse consumate. Con il modello di configurazione, i diritti vengono conteggiati in due modi: + [Licenze Drawdown](#container-floating-lic) + [Licenze fluttuanti](#container-floating-lic) #### Licenza Drawdown La licenza viene prelevata dal pool di licenze consentite al momento dell'uso. Tale autorizzazione viene verificata in modo permanente e non può essere restituita al pool di licenze. **Example di elaborare una quantità limitata di dati** Un utente ha il diritto di elaborare 500 GB di dati. Man mano che continuano a elaborare i dati, la quantità viene prelevata dal pool di 500 GB fino a esaurire tutte le licenze da 500 GB. Per le licenze drawdown, è possibile utilizzare l'operazione `CheckoutLicense` API per verificare le unità di licenza (diritti) utilizzate. **Example di backup su Amazon S3 per un certo numero di unità/anno** Disponi di un prodotto di storage che consente il backup su Amazon Simple Storage Service per un massimo di 1.024 unità di dati per un anno. L'applicazione può essere avviata utilizzando più istanze Amazon EC2. L'applicazione dispone di un meccanismo per tracciare e aggregare i dati. Il software richiama il funzionamento dell'`CheckoutLicense`API con l'ID del prodotto a ogni backup o a intervalli fissi per aggiornare le quantità consumate. In questo esempio, il software richiama l'operazione `CheckoutLicense` API per il check-out di 10 unità di dati. Quando la capacità totale raggiunge il limite di backup acquistato dal cliente, la chiamata API non riesce. **Richiesta** ``` 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" ``` **Risposta** ``` {"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" } ``` #### Licenze fluttuanti La licenza viene restituita al pool del numero consentito di licenze dopo l'uso. Per le licenze flottanti, l'applicazione estrae i permessi dal pool di autorizzazioni utilizzando l'operazione `CheckoutLicense` API quando la risorsa viene utilizzata. La risposta dell'operazione `CheckoutLicense` API include un token di consumo della licenza che è un identificatore univoco per il checkout. Il token di utilizzo della licenza può essere utilizzato per eseguire azioni aggiuntive sui diritti oggetto di check-out, ad esempio inserirli nuovamente nella licenza o estendere il check-out. Per ricontrollare i diritti nel pool, utilizza l'operazione `CheckInLicense` API quando la risorsa non è più in uso. ``` aws license-manager check-in-license --license-consumption-token "f1603b3c1f574b7284db84..." ``` In caso di mancato check-in dell'autorizzazione (nel caso in cui l'applicazione si sia bloccata), l'autorizzazione torna automaticamente nel pool dopo 60 minuti. Se la risorsa viene utilizzata per più di 60 minuti, è consigliabile mantenere l'autorizzazione esclusa dal pool utilizzando l'operazione `ExtendLicenseConsumption` API per tutto il tempo in cui la risorsa viene utilizzata. ``` aws license-manager extend-license-consumption --license-consumption-token "f1603b3c1f574b7284..." ``` **Example del numero di utenti a partire da un limite massimo fisso** Un utente ha diritto a 500 utenti simultanei sull'applicazione. Quando gli utenti accedono e si disconnettono, gli utenti vengono estratti e restituiti al pool di 500 utenti. Tuttavia, l'applicazione non può attirare più di 500 utenti dal pool perché 500 utenti simultanei è il limite massimo fisso. Per le autorizzazioni fluttuanti, è possibile utilizzare l'operazione `CheckInLicense` API per restituire le unità di licenza al pool di autorizzazioni. **Example del numero di utenti simultanei per un anno** Il prezzo del prodotto è basato sul numero di utenti simultanei. Il cliente acquista una licenza per 10 utenti per un anno. Il cliente avvia il software fornendo le autorizzazioni AWS Identity and Access Management (IAM). Quando un utente effettua l'accesso, l'applicazione richiama l'operazione `CheckoutLicense` API per ridurre la quantità di 1. Quando l'utente si disconnette, l'applicazione restituisce la licenza al pool chiamando l'operazione `CheckInLicense` API. Se non chiami`CheckInLicense`, l'unità di licenza verrà automaticamente registrata dopo 1 ora. **Nota** Nella richiesta seguente, `key-fingerprint` non è un valore segnaposto ma il valore effettivo dell'impronta digitale con cui verranno pubblicate tutte le licenze. **Richiesta** ``` 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" ``` **Risposta** ``` { "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" } ``` ### Modello di licenza a più livelli Il modello di licenza a più livelli dà diritto a un acquirente a un livello o livello specifico di funzionalità dell'applicazione dopo che l'acquirente ha acquistato una licenza. Puoi creare livelli per il tuo prodotto, come Basic, Intermediate e Premium. L'acquirente seleziona quindi uno dei livelli predefiniti. L'applicazione non ha bisogno di tracciare o misurare l'utilizzo dell'applicazione. Con il modello di licenza a più livelli, i diritti non vengono conteggiati, ma indicano invece un livello di servizio acquistato dal cliente. Se desideri offrire insieme funzionalità in bundle, sono preferibili i livelli. **Example dei livelli Basic, Intermediate e Premium** Un cliente può firmare un contratto per uno dei tre possibili livelli del software: Basic, Intermediate o Premium. Ciascuno di questi livelli ha i propri prezzi. Il software è in grado di identificare il livello a cui il cliente si è registrato richiamando l'operazione `CheckoutLicense` API e specificando tutti i livelli possibili nella richiesta. La risposta alla richiesta contiene l'autorizzazione corrispondente al livello acquistato dal cliente. Sulla base di queste informazioni, il software è in grado di fornire al cliente un'esperienza adeguata. #### Richiesta ``` 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" ``` #### Risposta ``` { "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 prerequisiti di integrazione Prima di pubblicare il prodotto, è necessario effettuare le seguenti operazioni: 1. Crea un nuovo prodotto contenitore in e prendi nota del relativo codice prodotto. Portale di gestione Marketplace AWS Per ulteriori informazioni, consulta [Panoramica: crea un prodotto contenitore](container-product-getting-started.md#create-container-product). 1. Utilizza un ruolo IAM per l'attività o il pod che esegue l'applicazione con le autorizzazioni IAM necessarie per chiamare `CheckoutLicense` le `ExtendLicenseConsumption` operazioni dell'`CheckInLicense`API e. Le autorizzazioni IAM richieste sono dettagliate nella seguente politica IAM. ------ #### [ 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. Effettua una chiamata di prova all'operazione `RegisterUsage` API con un record per tutte le dimensioni di prezzo che definisci. ## Integrazione di un prodotto contenitore con License Manager **Per integrare il prodotto basato su container con License Manager** 1. Imposta le autorizzazioni IAM per chiamare License Manager. Per ulteriori informazioni, consulta [AWS License Manager prerequisiti di integrazione](#container-LM-prereqs). 1. Scarica l' AWS SDK. **Nota** Non configurate AWS le credenziali all'interno del vostro software. AWS le credenziali per l'acquirente vengono ottenute automaticamente in fase di esecuzione quando il container è in esecuzione all'interno di un'istanza Amazon EC2, un'attività Amazon ECS o un pod Amazon EKS. 1. Aggiungi controlli di licenza al tuo prodotto. Il prodotto può richiamare l'operatività dell'`CheckoutLicense`API ovunque debba essere eseguito il controllo della licenza. Per verificare la licenza, il prodotto deve sapere: 1. L'emittente affidabile della licenza ()Marketplace AWS 1. Lo SKU del prodotto (ID del prodotto) dell'applicazione 1. Il diritto a verificare la presenza di questa applicazione Le chiamate API variano in base al tipo di licenze tariffarie configurate. 1. Pubblica la tua scheda di prodotti su. Marketplace AWS ## Operazioni dell'API License Manager Per gestire le licenze archiviate nell'account License Manager del cliente, il software può utilizzare le seguenti operazioni API: + `GetLicense`— Un'API che il software può interrogare. Recupera lo stato di una licenza acquistata (ossia scaduta o in scadenza a breve) e invia una notifica di stato al cliente. + `CheckoutLicense`— Scopre le licenze acquistate dall'utente. È inoltre possibile utilizzare l'operazione `CheckoutLicense` API per aggiornare la quantità di licenze quando l'utente ha consumato una certa quantità di licenze. Con`CheckoutLicense`, puoi continuare a controllare le quantità di licenze utilizzate dal cliente. Quando il cliente esaurisce tutte le licenze, questa chiamata restituisce un errore. Per informazioni sulla cadenza di esecuzione consigliata, consulta. `CheckoutLicense` [Rinnovi e aggiornamenti delle licenze](#container-LM-lic-renew-upgrade) + `ExtendLicenseConsumption`— In caso di dimensioni variabili, quando il software rileva una licenza, la licenza tornerà automaticamente nel pool dopo 60 minuti. Se desideri prolungare il periodo di validità della licenza, utilizza l'operazione `ExtendLicenseConsumption` API per estendere la licenza per altri 60 minuti. + `CheckInLicense`— In caso di dimensioni mobili, quando desideri restituire la licenza al pool di autorizzazioni, utilizza l'`CheckInLicense`operazione API. + `ListReceivedLicenses`API: elenca le licenze acquistate dall'acquirente. ## Rinnovi e aggiornamenti delle licenze I clienti possono rinnovare o aggiornare le proprie licenze su. Portale di gestione Marketplace AWS Dopo aver effettuato un acquisto aggiuntivo, Marketplace AWS genera una nuova versione della licenza che riflette i nuovi diritti. Il software legge le nuove autorizzazioni utilizzando le stesse operazioni API. Non è necessario fare nulla di diverso in termini di integrazione del License Manager per gestire i rinnovi e gli aggiornamenti. A causa di rinnovi di licenza, upgrade, annullamenti e così via, consigliamo che il prodotto richiami l'operatività dell'`CheckoutLicense`API a cadenza regolare mentre il prodotto è in uso. Utilizzando il funzionamento dell'`CheckoutLicense`API a cadenza regolare, il prodotto è in grado di rilevare cambiamenti nelle autorizzazioni, ad esempio aggiornamenti e scadenze. Ti consigliamo di eseguire la chiamata `CheckoutLicense` API ogni 15 minuti. # Integrazione di an Marketplace AWS for Containers Anywhere con License Manager In qualità di Marketplace AWS venditore, puoi effettuare l'integrazione AWS License Manager con un prodotto Marketplace AWS for Containers Anywhere per Amazon EKS Anywhere, Amazon ECS Anywhere, Amazon EC2 o un'infrastruttura locale. Le seguenti sezioni forniscono istruzioni per questa integrazione. Per informazioni generali sull'integrazione di License Manager con Marketplace AWS, inclusi i modelli di licenza disponibili, vedere[Prezzi contrattuali per prodotti in container con AWS License Manager](container-license-manager-integration.md). Per ulteriori informazioni in merito AWS License Manager, consulta la [Guida per AWS License Manager l'utente](https://docs.aws.amazon.com/license-manager/latest/userguide/license-manager.html) e la [AWS License Manager](https://docs.aws.amazon.com/cli/latest/reference/license-manager/index.html)sezione del *AWS CLI Command Reference*. **Topics** + [Integrazione di un prodotto Marketplace AWS for Containers Anywhere con License Manager](#containers-anywhere-integrate-with-LM) + [Test dell'integrazione con License Manager a livello locale](#container-testing-LM-integration-locally) + [Test dell'integrazione di License Manager su Amazon EKS](#container-testing-LM-integration-EKS) + [Diritti di licenza fluttuanti con License Manager](#container-LM-floating-license) + [Le migliori pratiche per l'integrazione con License Manager per le distribuzioni locali](#container-LM-best-practices-on-prem) + [`LicenseManagerCredentialsProvider`- Implementazione Java](#container-license-manager-cred-provider-java) + [`LicenseManagerCredentialsProvider`- implementazione `Golang`](#container-license-manager-cred-provider-golang) ## Integrazione di un prodotto Marketplace AWS for Containers Anywhere con License Manager Utilizza le seguenti istruzioni per integrare il tuo prodotto Marketplace AWS for Containers Anywhere con AWS License Manager. **Per integrare il prodotto Marketplace AWS for Containers Anywhere con License Manager** 1. Apri un browser Web e accedi a [Portale di gestione Marketplace AWS](https://aws.amazon.com/marketplace/management/). 1. Crea un ID prodotto per il tuo prodotto contenitore eseguendo i seguenti passaggi. Utilizzerai questo ID nell'immagine del contenitore per i controlli della licenza in una fase successiva. 1. Dalla barra dei menu, espandi **Risorse** e scegli **Contenitore**. 1. **Inserisci un nome rivolto ai clienti per il tuo prodotto e scegli Crea.** Puoi modificare questo nome in un secondo momento. 1. Prendi nota dell'**ID del prodotto**. Lo utilizzerai per creare o aggiornare i dettagli dei prezzi del prodotto. **Suggerimento** Se perdi l'ID del prodotto, puoi trovarlo nel menu **Risorse Portale di gestione Marketplace AWS ** scegliendo **Contenitore**. La pagina **Contenitori** mostra un elenco dei tuoi prodotti con il prodotto associato IDs. 1. Scarica l' AWS SDK pubblico più recente e installalo nell'applicazione contenitore. Puoi trovare le istruzioni di installazione per il tuo AWS SDK preferito in [Tools to Build on AWS](https://aws.amazon.com/tools/). **Nota** Per richiamare le operazioni dell'API License Manager da Amazon EKS Anywhere o da un cluster Kubernetes non fornito da AWS, devi utilizzare un SDK supportato. AWS Per visualizzare un elenco di quelli supportati AWS SDKs, consulta [Utilizzo](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts-minimum-sdk.html) di un SDK supportato. AWS 1. Crea un AWS License Manager client con un provider di credenziali personalizzato in modo che possa fornire le credenziali all'applicazione contenitore distribuita sia in locale che in locale AWS . Per il codice sorgente completo per un provider di credenziali personalizzato`LicenseCredentialProvider`, consulta le seguenti sezioni: + [`LicenseManagerCredentialsProvider`- Implementazione Java](#container-license-manager-cred-provider-java) + [`LicenseManagerCredentialsProvider`- implementazione `Golang`](#container-license-manager-cred-provider-golang) `LicenseCredentialsProvider`estende la catena di provider di credenziali predefinita dell' AWS SDK per l'uso in locale aggiungendo. `LicenseManagerTokenCredentialsProvider` Ciò fornisce le credenziali utilizzando i token di identità emessi da License Manager OIDC in ambienti locali. È necessario includere il codice sorgente di nel classpath dell'applicazione`LicenseCredentialsProvider`. **Nota** L'estensione `DefaultCredentialsProvider` consente alla stessa applicazione contenitore di ottenere le credenziali durante l'esecuzione in un ambiente locale AWS e durante l'esecuzione in un ambiente locale. Se l'applicazione contenitore utilizza già una catena di fornitori di credenziali personalizzata anziché quella predefinita, può anche essere estesa aggiungendola `LicenseManagerTokenCredentialsProvider` alla catena personalizzata. Il seguente frammento di codice è un esempio di creazione di un AWS License Manager client utilizzando Java. ``` LicenseManagerClientBuilder clientBuilder = LicenseManagerClient.builder().credentialsProvider(LicenseCredentialsProvider.create()); ``` 1. Chiama l'operazione `CheckoutLicense` API utilizzando il `aws license-manager checkout-license` comando di ogni immagine di contenitore a pagamento nella tua offerta di prodotti. Ciò verifica che l'acquirente sia autorizzato a utilizzare una licenza per l'applicazione. Se l'acquirente ha diritto alla richiesta, `CheckoutLicense` ci riesce e restituisce i diritti richiesti e i relativi valori. Se l'acquirente non ha diritto alla richiesta, `CheckoutLicense` genera un'eccezione. I seguenti parametri sono necessari quando si chiama l'operazione `CheckoutLicense` API: + `CheckoutType`— I valori validi sono `PROVISIONAL` o`PERPETUAL`: + Da utilizzare `PERPETUAL` quando la quantità di diritti prelevati dal pool sarà esaurita. Esempio: l'acquirente ha il diritto di elaborare 500 GB di dati. Man mano che continuano a elaborare i dati, la quantità viene prelevata ed esaurita dal pool di 500 GB. + `PROVISIONAL`Utilizzatelo per le licenze flottanti, in cui le autorizzazioni vengono estratte dal pool e restituite dopo l'uso. Esempio: l'utente ha diritto a 500 utenti simultanei sull'applicazione. Quando gli utenti accedono o si disconnettono, gli utenti vengono estratti o restituiti al pool di 500 utenti. Per ulteriori informazioni sui diritti di licenza fluttuanti, consulta. [Diritti di licenza fluttuanti con License Manager](#container-LM-floating-license) + `ClientToken`— Un identificatore univoco con distinzione tra maiuscole e minuscole. Si consiglia di utilizzare un UUID casuale per ogni richiesta univoca. + `Entitlements`— Un elenco di diritti da verificare. + Per i diritti relativi alle funzionalità, fornite le proprietà `Name` and `Unit` come segue. ``` { "Name": "", "Unit": "None" } ``` + Per i diritti conteggiati, fornite le proprietà `Name``Unit`, e `Count` come segue. ``` { "Name": "", "Unit": "", "Value": } ``` + `KeyFingerprint`— L'impronta digitale chiave per le licenze rilasciate da è. Marketplace AWS `aws:294406891311:AWS/Marketplace:issuer-fingerprint` L'utilizzo di questa chiave digitale garantisce che la licenza sia rilasciata da Marketplace AWS e non da un'entità inaffidabile. + `ProductSKU`— L'ID del prodotto generato Portale di gestione Marketplace AWS nei passaggi precedenti. Il seguente frammento è un esempio di chiamata che utilizza l'operazione `CheckoutLicense` API utilizzando il. 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" ``` **Nota** Per controllare le licenze, le applicazioni container richiedono l'accesso alla rete in uscita per utilizzare License Manager. Le applicazioni distribuite in locale potrebbero presentare un accesso alla rete in uscita inaffidabile o lento. Queste applicazioni devono includere tentativi adeguati quando si chiama License Manager. Per ulteriori informazioni, consulta [Le migliori pratiche per l'integrazione con License Manager per le distribuzioni locali](#container-LM-best-practices-on-prem). 1. Chiamate il servizio operativo dell'`CheckoutLicense`API a cadenza regolare per identificare eventuali modifiche alle licenze dei clienti dovute a rinnovi, upgrade o cancellazioni effettuate il. Marketplace AWS La cadenza dipende dall'applicazione. Ti consigliamo di controllare le licenze una volta al giorno per rilevare automaticamente le modifiche senza l'intervento dell'acquirente. Un'applicazione distribuita in locale potrebbe avere un accesso inaffidabile alla rete in uscita per controllare le licenze con cadenza regolare. In questi casi, l'applicazione deve utilizzare licenze memorizzate nella cache per una resilienza sufficiente. Per ulteriori informazioni, consulta [Le migliori pratiche per l'integrazione con License Manager per le distribuzioni locali](#container-LM-best-practices-on-prem). 1. Dopo aver integrato la `CheckoutLicense` chiamata con l'applicazione contenitore, crea una nuova versione dell'immagine del contenitore Docker con le modifiche. 1. Aggiorna la tabella Helm dell'applicazione per accettare un segreto Kubernetes come input opzionale che contiene la configurazione per accedere alle licenze tramite License Manager. APIs Il segreto di configurazione conterrà un token di identità rilasciato da License Manager e un AWS Identity and Access Management ruolo che verrà utilizzato dal provider di credenziali personalizzate descritto in precedenza per ottenere AWS le credenziali per chiamare License Manager APIs quando l'applicazione contenitore viene distribuita in locale. Inoltre, aggiungi Regione AWS come input con un valore predefinito di. `us-east-1` Gli acquirenti che implementano l'applicazione container in locale possono creare il segreto di Kubernetes attraverso l'esperienza Marketplace AWS dell'acquirente per i prodotti container. Fornisci il nome segreto di Kubernetes come input per il comando. `helm install` Il segreto di configurazione è configurato nel seguente formato. ``` 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. Aggiorna il modello di distribuzione dell'applicazione nel grafico Helm per le immagini dei contenitori integrate con AWS License Manager per includere quanto segue: + Account di servizio per pod: l'account di servizio è necessario per le distribuzioni Helm su Amazon EKS. Viene utilizzato per ottenere le autorizzazioni per chiamare le operazioni dell'API License Manager impostando i ruoli IAM per l'account di servizio sull'immagine del contenitore. Per ulteriori informazioni sui ruoli IAM per gli account di servizio, consulta [Ruoli IAM per gli account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html). + Accesso alla licenza per le distribuzioni locali: il segreto di configurazione della licenza è necessario per fornire le credenziali e le autorizzazioni appropriate per chiamare le operazioni dell'API License Manager per le distribuzioni Helm in ambienti locali. Gli acquirenti genereranno e forniranno il segreto della licenza a Helm in base all'esperienza dell'acquirente. Marketplace AWS Il seguente frammento di codice è un esempio di specifica di distribuzione con l'account del servizio, la configurazione della licenza e l'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 }} ``` **Nota** Il segreto di configurazione della licenza è facoltativo. Gli acquirenti utilizzano il valore solo per le distribuzioni locali. Per le AWS distribuzioni, le specifiche di distribuzione devono includere un account di servizio per le immagini integrate di License Manager. 1. Verifica l'integrazione del License Manager localmente e su Amazon EKS eseguendo i passaggi nelle seguenti sezioni: 1. [Test dell'integrazione con License Manager a livello locale](#container-testing-LM-integration-locally) 1. [Test dell'integrazione di License Manager su Amazon EKS](#container-testing-LM-integration-EKS) 1. Dopo aver verificato con successo l'integrazione di License Manager AWS sia in locale che in locale, puoi creare la tua lista di prodotti container seguendo la procedura riportata di seguito. [Panoramica: crea un prodotto contenitore](container-product-getting-started.md#create-container-product) ## Test dell'integrazione con License Manager a livello locale Puoi utilizzare minikube o qualsiasi altra configurazione per testare l'integrazione del License Manager su qualsiasi cluster Kubernetes a livello locale. Assicurati che il cluster Kubernetes disponga dell'accesso a Internet in uscita per chiamare le operazioni dell'API License Manager. **Per testare localmente un'integrazione di License Manager** 1. Crea una licenza di prova in un account venditore di prova con i diritti desiderati. Per configurare una licenza di prova, consulta la sezione *AWS License Manager API [CreateLicense](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_CreateLicense.html)*Reference. In alternativa, utilizza lo script seguente per creare una licenza di prova e quindi creare una concessione di licenza a un account acquirente di prova per utilizzare la licenza. Lo script seguente utilizza le credenziali dell'account venditore di prova. ``` 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. Crea un segreto Kubernetes con il token di licenza e il ruolo IAM utilizzando il formato segreto definito in precedenza. Utilizza l'operazione `CreateToken` API License Manager per generare un token di licenza. Quindi, utilizza l'operazione `CreateRole` API IAM per creare un ruolo IAM con autorizzazioni e una policy di fiducia. Vedi l'esempio nello script seguente. Lo script seguente utilizza le credenziali dell'account acquirente di prova. ``` 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. Configura qualsiasi cluster Kubernetes ospitato all'esterno. AWS Usalo per verificare che le applicazioni container possano connettersi all' AWS License Manager API da ambienti diversi AWS e che il provider di credenziali personalizzate sia ben integrato nell'applicazione. 1. Distribuisci il token di licenza e il ruolo IAM generati in precedenza nel cluster Kubernetes locale. ``` kubectl create secret generic "awsmp-license-access-config" \ --from-literal=license_token=${TOKEN} \ --from-literal=iam_role=${ROLE_ARN} ``` 1. Implementa la tua applicazione tramite Helm inserendo il nome segreto e verifica che l'applicazione possa richiamare le operazioni API di License Manager per eseguire i controlli di autorizzazione. Per le modifiche a Helm e alle specifiche di distribuzione, consulta la Fase 9 in. [Integrazione di un prodotto Marketplace AWS for Containers Anywhere con License Manager](#containers-anywhere-integrate-with-LM) ## Test dell'integrazione di License Manager su Amazon EKS Puoi anche testare l'integrazione di License Manager su Amazon EKS. Esegui un test per assicurarti che l'applicazione possa richiamare le operazioni API di License Manager senza il segreto di configurazione della licenza. Assicurati inoltre che l'account di servizio possa essere utilizzato per configurare IAM Roles for Service Accounts (IRSA) e fornire le credenziali pertinenti all'applicazione. **Per testare un'integrazione di License Manager su Amazon EKS** 1. Crea una licenza di prova in un account venditore di prova con i diritti desiderati. Consulta il [riferimento all'CreateLicense API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_CreateLicense.html) per configurare la tua licenza di prova oppure usa lo script seguente per crearne una e concedere una licenza a un account acquirente di prova per utilizzare la licenza. Lo script seguente utilizza le credenziali dell'account venditore di prova. ``` 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. Crea un cluster Amazon EKS di prova delle configurazioni desiderate o esegui i seguenti comandi per utilizzare una configurazione predefinita. ``` 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. Crea un account di servizio per un cluster esistente e associalo a un ruolo IAM. Il comando seguente crea un ruolo IAM con`AWSLicenseManagerConsumptionPolicy`. Quindi, il comando lo collega all'account di `test_sa` servizio del cluster Amazon EKS in cui devono essere distribuite le immagini integrate di License Manager. Di conseguenza, l'account del servizio può ottenere le credenziali appropriate per chiamare le operazioni API di License Manager. ``` 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. Distribuisci l'applicazione tramite Helm nell'account di servizio in cui il ruolo IAM è associato al comando precedente. Verificate che l'applicazione sia in grado di richiamare le operazioni dell'API License Manager per eseguire i controlli delle autorizzazioni. ## Diritti di licenza fluttuanti con License Manager Con le licenze fluttuanti, quando gli utenti accedono all'applicazione, viene estratta una licenza dal pool di licenze disponibili. Quando gli utenti si disconnettono, le licenze vengono aggiunte nuovamente al pool di licenze disponibili. Per le licenze flottanti, l'applicazione utilizza l'operazione `CheckoutLicense` API per estrarre le autorizzazioni dal pool di autorizzazioni quando viene utilizzata la risorsa. La risposta dell'operazione `CheckoutLicense` API include un token di consumo della licenza che è un identificatore univoco per il checkout. Il token di utilizzo delle licenze può eseguire azioni aggiuntive sui diritti di accesso sottoposti a check-out, ad esempio archiviarli nuovamente nel pool di licenze o estendere il check-out. Quando la risorsa non è più in uso, l'applicazione utilizza l'operazione `CheckInLicense` API per ricontrollare l'autorizzazione nel pool. ``` aws license-manager check-in-license \ --license-consumption-token "f1603b3c1f574b7284db84a9e771ee12" ``` Se il ripristino di una licenza nel pool non riesce, ad esempio, se l'applicazione si blocca durante l'operazione, l'autorizzazione viene ricontrollata automaticamente nel pool dopo 60 minuti. Per questo motivo, se la risorsa viene utilizzata per più di 60 minuti, è consigliabile mantenere l'autorizzazione selezionata dal pool. A tale scopo, utilizzate l'operazione `ExtendLicenseConsumption` API fintanto che la risorsa viene utilizzata. ``` aws license-manager extend-license-consumption \ --license-consumption-token "f1603b3c1f574b7284db84a9e771ee12" ``` ## Le migliori pratiche per l'integrazione con License Manager per le distribuzioni locali Le implementazioni di applicazioni container in un ambiente locale potrebbero comportare un accesso inaffidabile alla rete in uscita. Utilizza le seguenti best practice per aggiungere resilienza ed evitare interruzioni del servizio agli acquirenti a causa di potenziali problemi causati da una scarsa connettività Internet: + **Riprova adeguata**: problemi transitori di rete possono impedire la connessione dell'applicazione. AWS License Manager Implementa nuovi tentativi per un massimo di 30 minuti, con backoff esponenziale. Questo può aiutare a evitare interruzioni a breve termine o problemi di rete. + **Evita i limiti rigidi**: le applicazioni distribuite in cluster connessi possono controllare regolarmente le licenze per identificare eventuali modifiche dovute ad aggiornamenti o rinnovi. Con un accesso in uscita inaffidabile, l'applicazione potrebbe non essere in grado di identificare tali modifiche. Ove possibile, l'applicazione dovrebbe evitare interruzioni del servizio agli acquirenti dovute all'impossibilità di controllare le licenze tramite License Manager. Le applicazioni possono ricorrere a una versione di prova gratuita o open source alla scadenza della licenza e non possono verificare se una licenza è valida. + **Informa i clienti**: quando si utilizza una licenza memorizzata nella cache, eventuali modifiche alla licenza (inclusi rinnovi o aggiornamenti) non si riflettono automaticamente sul carico di lavoro in esecuzione. Informa i tuoi clienti (che devono consentire nuovamente e temporaneamente l'accesso in uscita all'applicazione) in modo che l'applicazione possa aggiornare la licenza memorizzata nella cache. Ad esempio, informate i clienti tramite l'applicazione stessa o tramite la relativa documentazione. Analogamente, quando ricorri a una serie inferiore di funzionalità, comunica ai clienti che i loro diritti sono esauriti o che la licenza è scaduta. Quindi, possono scegliere di eseguire l'aggiornamento o il rinnovo. ## `LicenseManagerCredentialsProvider`- Implementazione Java `LicenseCredentialsProvider`estende la catena di provider di credenziali predefinita dell' AWS SDK per l'uso in locale aggiungendo. `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`fornisce credenziali utilizzando token di identità emessi da License Manager OIDC in ambienti locali. È necessario includere il codice sorgente di nel percorso di classe dell'applicazione`LicenseCredentialsProvider`. ``` 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`- implementazione `Golang` **`LicenseCredentialsProvider`** `LicenseCredentialsProvider`estende la catena di provider di credenziali predefinita dell' AWS SDK per l'uso in locale aggiungendo. `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`fornisce credenziali utilizzando token di identità emessi da License Manager OIDC in ambienti locali. È necessario includere il codice sorgente di nel percorso di classe dell'applicazione`LicenseCredentialsProvider`. ``` 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 } } ```