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à.
# Lavorare con i gruppi di pacchetti in CodeArtifact
*I gruppi di pacchetti* possono essere utilizzati per applicare la configurazione a più pacchetti che corrispondono a uno schema definito utilizzando il formato del pacchetto, lo spazio dei nomi del pacchetto e il nome del pacchetto. È possibile utilizzare i gruppi di pacchetti per configurare più comodamente i controlli di origine dei pacchetti per più pacchetti. I controlli di origine dei pacchetti vengono utilizzati per bloccare o consentire l'inserimento o la pubblicazione di nuove versioni dei pacchetti, proteggendo gli utenti da azioni dannose note come attacchi di sostituzione delle dipendenze.
Ogni dominio contiene CodeArtifact automaticamente un gruppo di pacchetti root. Per impostazione predefinita`/*`, questo gruppo di pacchetti radice contiene tutti i pacchetti e consente alle versioni dei pacchetti di accedere ai repository del dominio da tutti i tipi di origine. Il gruppo di pacchetti root può essere modificato, ma non può essere eliminato.
La funzionalità Package Group Configuration funziona in modo sostanzialmente coerente quando si crea un nuovo gruppo di pacchetti o si elimina un gruppo di pacchetti esistente. Ciò significa che al momento della creazione o dell'eliminazione di un gruppo di pacchetti, i controlli di origine verranno applicati ai pacchetti associati previsti, ma con un certo ritardo dovuto all'eventuale comportamento coerente. Il tempo necessario per raggiungere la coerenza finale dipende dal numero di gruppi di pacchetti nel dominio e dal numero di pacchetti nel dominio. Potrebbe esserci un breve periodo in cui i controlli di origine non si riflettono immediatamente sui pacchetti associati dopo la creazione o l'eliminazione di un gruppo di pacchetti.
Inoltre, gli aggiornamenti ai controlli di origine dei gruppi di pacchetti sono efficaci quasi immediatamente. A differenza della creazione o dell'eliminazione di gruppi di pacchetti, le modifiche ai controlli di origine di un gruppo di pacchetti esistente si riflettono sui pacchetti associati senza lo stesso ritardo.
Questi argomenti contengono informazioni sui gruppi di pacchetti in AWS CodeArtifact.
**Topics**
+ [Crea un gruppo di pacchetti](create-package-group.md)
+ [Visualizza o modifica un gruppo di pacchetti](view-edit-package-group.md)
+ [Eliminare un gruppo di pacchetti](delete-package-group.md)
+ [Controlli dell'origine dei gruppi di pacchetti](package-group-origin-controls.md)
+ [Sintassi della definizione del gruppo di pacchetti e comportamento di abbinamento](package-group-definition-syntax-matching-behavior.md)
+ [Assegna un tag a un gruppo di pacchetti](package-group-tags.md)
# Crea un gruppo di pacchetti
È possibile creare un gruppo di pacchetti utilizzando la CodeArtifact console, il AWS Command Line Interface (AWS CLI) o CloudFormation. Per ulteriori informazioni sulla gestione dei gruppi di CodeArtifact pacchetti con CloudFormation, vedere[Creare CodeArtifact risorse con AWS CloudFormation](cloudformation-codeartifact.md).
## Creare un gruppo di pacchetti (console)
1. Apri la AWS CodeArtifact console su [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. Nel riquadro di navigazione, scegli **Domini**, quindi scegli il dominio in cui desideri creare un gruppo di pacchetti.
1. Scegli **Package groups** e scegli **Create package group**.
1. In **Definizione del gruppo di pacchetti**, inserisci la definizione del gruppo di pacchetti per il tuo gruppo di pacchetti. La definizione del gruppo di pacchetti determina quali pacchetti sono associati al gruppo. È possibile inserire manualmente la definizione del gruppo di pacchetti con testo oppure utilizzare la modalità visiva per effettuare selezioni e la definizione del gruppo di pacchetti verrà creata automaticamente.
1. Per utilizzare la modalità visiva per creare la definizione del gruppo di pacchetti:
1. Scegliete **Visual** per passare alla modalità visiva.
1. In **Formato Package**, scegli il formato dei pacchetti da associare a questo gruppo.
1. In **Namespace (Ambito)**, scegli i criteri dello spazio dei nomi in base ai quali effettuare la corrispondenza.
+ **Uguale: corrisponde esattamente allo spazio dei nomi** specificato. Se selezionato, inserisci lo spazio dei nomi su cui eseguire la corrispondenza.
+ **Vuoto**: abbina i pacchetti senza namespace.
+ **Inizia con una parola**: corrisponde ai namespace che iniziano con una parola specificata. Se selezionato, inserisci la parola prefisso in base alla quale abbinare. Per ulteriori informazioni sulle parole e sui limiti delle parole, vedere[Parole, confini delle parole e corrispondenza dei prefissi](package-group-definition-syntax-matching-behavior.md#package-group-word-boundary-prefix).
+ **Tutti**: abbina i pacchetti in tutti i namespace.
1. Se è selezionato **Uguale** a, **Vuoto** o **Inizia con parola**, in **Nome pacchetto scegli i criteri relativi al nome** del pacchetto in base ai quali trovare la corrispondenza.
+ **Esattamente uguale**: corrisponde esattamente al nome del pacchetto specificato. Se selezionato, inserisci il nome del pacchetto su cui abbinare.
+ **Inizia con il prefisso**: abbina i pacchetti che iniziano con il prefisso specificato.
+ **Inizia con una parola**: abbina i pacchetti che iniziano con una parola specificata. Se selezionato, inserisci la parola con il prefisso in base alla quale abbinare. Per ulteriori informazioni sulle parole e sui limiti delle parole, vedere[Parole, confini delle parole e corrispondenza dei prefissi](package-group-definition-syntax-matching-behavior.md#package-group-word-boundary-prefix).
+ **Tutti**: abbina tutti i pacchetti.
1. Scegli **Avanti** per rivedere la definizione.
1. Per inserire la definizione del gruppo di pacchetti con testo:
1. Scegliete **Testo** per passare alla modalità testo.
1. In **Definizione del gruppo di pacchetti**, immettere la definizione del gruppo di pacchetti. Per ulteriori informazioni sulla sintassi della definizione del gruppo di pacchetti, vedere[Sintassi della definizione del gruppo di pacchetti e comportamento di abbinamento](package-group-definition-syntax-matching-behavior.md).
1. Scegliete **Avanti** per rivedere la definizione.
1. In **Revisione della definizione**, esamina i pacchetti che verranno inclusi nel nuovo gruppo di pacchetti in base alla definizione fornita in precedenza. Dopo la revisione, scegli **Avanti**.
1. In **Informazioni sul gruppo di pacchetti**, aggiungi facoltativamente una descrizione e un indirizzo email di contatto per il gruppo di pacchetti. Scegli **Next (Successivo)**.
1. In **Package origin controls**, configura i controlli di origine da applicare ai pacchetti del gruppo. Per ulteriori informazioni sui controlli di origine dei gruppi di pacchetti, vedere[Controlli dell'origine dei gruppi di pacchetti](package-group-origin-controls.md).
1. Scegliete **Crea gruppo di pacchetti**.
## Crea un gruppo di pacchetti (AWS CLI)
Usa il `create-package-group` comando per creare un gruppo di pacchetti nel tuo dominio. Per l'`--package-group`opzione, inserisci la definizione del gruppo di pacchetti che determina quali pacchetti sono associati al gruppo. Per ulteriori informazioni sulla sintassi della definizione dei gruppi di pacchetti, vedere[Sintassi della definizione del gruppo di pacchetti e comportamento di abbinamento](package-group-definition-syntax-matching-behavior.md).
In caso contrario, configuralo AWS CLI seguendo la procedura riportata di seguito. [Configurazione con AWS CodeArtifact](get-set-up-for-codeartifact.md)
```
aws codeartifact create-package-group \
--domain my_domain \
--package-group '/nuget/*' \
--domain-owner 111122223333 \
--contact-info contact@email.com \
--description "a new package group" \
--tags key=key1,value=value1
```
# Visualizza o modifica un gruppo di pacchetti
È possibile visualizzare un elenco di tutti i gruppi di pacchetti, visualizzare i dettagli di un gruppo di pacchetti specifico o modificare i dettagli o la configurazione di un gruppo di pacchetti utilizzando la CodeArtifact console o AWS Command Line Interface (AWS CLI).
## Visualizza o modifica un gruppo di pacchetti (console)
1. Apri la AWS CodeArtifact console su [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. Nel riquadro di navigazione, scegli **Domini**, quindi scegli il dominio che contiene il gruppo di pacchetti che desideri visualizzare o modificare.
1. Scegli **Gruppi di pacchetti** e scegli il gruppo di pacchetti che desideri visualizzare o modificare.
1. In **Dettagli**, visualizza le informazioni sul gruppo di pacchetti, tra cui il gruppo principale, la descrizione, l'ARN, l'e-mail di contatto e i controlli di origine del pacchetto.
1. In **Sottogruppi**, visualizza un elenco di gruppi di pacchetti che hanno questo gruppo come gruppo principale. I gruppi di pacchetti in questo elenco possono ereditare le impostazioni da questo gruppo di pacchetti. Per ulteriori informazioni, consulta [Gerarchia dei gruppi di pacchetti e specificità del modello](package-group-definition-syntax-matching-behavior.md#package-group-hierarchy-pattern-specificity).
1. In **Pacchetti**, visualizza i pacchetti che appartengono a questo gruppo di pacchetti in base alla definizione del gruppo di pacchetti. Nella colonna **Forza**, puoi vedere la forza dell'associazione dei pacchetti. Per ulteriori informazioni, consulta [Gerarchia dei gruppi di pacchetti e specificità del modello](package-group-definition-syntax-matching-behavior.md#package-group-hierarchy-pattern-specificity).
1. Per modificare le informazioni sul gruppo di pacchetti, scegli **Modifica gruppo di pacchetti**.
1. In **Informazioni**, aggiorna la descrizione o le informazioni di contatto del gruppo di pacchetti. Non è possibile modificare la definizione di un gruppo di pacchetti.
1. In **Package group origin controls**, aggiorna le impostazioni di controllo dell'origine del gruppo di pacchetti, che determinano in che modo i pacchetti associati possono entrare nei repository nel dominio. Per ulteriori informazioni, consulta [Controlli dell'origine dei gruppi di pacchetti](package-group-origin-controls.md).
## Visualizza o modifica un gruppo di pacchetti ()AWS CLI
Utilizzate i seguenti comandi per visualizzare o modificare i gruppi di pacchetti con AWS CLI. In caso contrario, configurali AWS CLI seguendo la procedura riportata in[Configurazione con AWS CodeArtifact](get-set-up-for-codeartifact.md).
Per visualizzare tutti i gruppi di pacchetti in un dominio, usa il `list-package-groups` comando.
```
aws codeartifact list-package-groups \
--domain my_domain \
--domain-owner 111122223333
```
Per visualizzare i dettagli su un gruppo di pacchetti, usa il `describe-package-group` comando. Per ulteriori informazioni sulle definizioni dei gruppi di pacchetti, vedere[Sintassi ed esempi per la definizione dei gruppi di pacchetti](package-group-definition-syntax-matching-behavior.md#package-group-definition-syntax-examples).
```
aws codeartifact describe-package-group \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*'
```
Per visualizzare i gruppi di pacchetti figli di un gruppo di pacchetti, utilizzare il `list-sub-package-groups` comando.
```
aws codeartifact list-sub-package-groups \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*' \
```
Per visualizzare il gruppo di pacchetti associato a un pacchetto, utilizzare il `get-associated-package-group` comando. È necessario utilizzare il nome e lo spazio dei nomi normalizzati del pacchetto per i formati di pacchetto NuGet Python e Swift. [Per ulteriori informazioni su come vengono normalizzati i nomi dei pacchetti e gli spazi dei nomi, consulta la documentazione sulla normalizzazione dei nomi di [NuGet](nuget-name-normalization.md)[Python](python-name-normalization.md) e Swift.](swift-name-normalization.md)
```
aws codeartifact get-associated-package-group \
--domain my_domain \
--domain-owner 111122223333 \
--format npm \
--package packageName \
--namespace scope
```
Per modificare un gruppo di pacchetti, usa il comando. `update-package-group` Questo comando viene utilizzato per aggiornare le informazioni di contatto o la descrizione di un gruppo di pacchetti. Per informazioni sulle impostazioni di controllo dell'origine dei gruppi di pacchetti e sulla loro aggiunta o modifica, vedere[Controlli dell'origine dei gruppi di pacchetti](package-group-origin-controls.md). Per ulteriori informazioni sulle definizioni dei gruppi di pacchetti, vedere [Sintassi ed esempi per la definizione dei gruppi di pacchetti](package-group-definition-syntax-matching-behavior.md#package-group-definition-syntax-examples)
```
aws codeartifact update-package-group \
--domain my_domain \
--package-group '/nuget/*' \
--domain-owner 111122223333 \
--contact-info contact@email.com \
--description "updated package group description"
```
# Eliminare un gruppo di pacchetti
È possibile eliminare un gruppo di pacchetti utilizzando la CodeArtifact console o AWS Command Line Interface (AWS CLI).
Notate il seguente comportamento quando eliminate i gruppi di pacchetti:
+ Il gruppo di pacchetti root,`/*`, non può essere eliminato.
+ I pacchetti e le versioni dei pacchetti associati a quel gruppo di pacchetti non vengono eliminati.
+ Quando un gruppo di pacchetti viene eliminato, i gruppi di pacchetti figli diretti diventeranno figli del gruppo di pacchetti principale diretto del gruppo di pacchetti. Pertanto, se uno qualsiasi dei gruppi di figli eredita delle impostazioni dal genitore, tali impostazioni potrebbero cambiare.
## Eliminare un gruppo di pacchetti (console)
1. Apri la AWS CodeArtifact console su [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. Nel riquadro di navigazione, scegli **Domini**, quindi scegli il dominio che contiene il gruppo di pacchetti che desideri visualizzare o modificare.
1. Scegli **Package groups**.
1. Scegli il gruppo di pacchetti che desideri eliminare e scegli **Elimina**.
1. Inserisci delete nel campo e scegli **Elimina**.
## Eliminare un gruppo di pacchetti (AWS CLI)
Per eliminare un gruppo di pacchetti, utilizzate il `delete-package-group` comando.
```
aws codeartifact delete-package-group \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*'
```
# Controlli dell'origine dei gruppi di pacchetti
I controlli di origine dei pacchetti vengono utilizzati per configurare il modo in cui le versioni dei pacchetti possono entrare in un dominio. È possibile impostare i controlli di origine su un gruppo di pacchetti per configurare il modo in cui le versioni di ogni pacchetto associato al gruppo di pacchetti possono accedere a repository specifici nel dominio.
Le impostazioni di controllo dell'origine dei gruppi di pacchetti sono le seguenti:
+ [Impostazioni di restrizione](#package-group-origin-control-settings-restrictions): Queste impostazioni definiscono se i pacchetti possono accedere a un repository CodeArtifact da archivi di pubblicazione, interni o pubblici esterni.
+ [Elenchi di repository consentiti](#package-group-origin-control-settings-repositories): Ogni impostazione di restrizione può essere impostata per consentire l'utilizzo di archivi specifici. Se un'impostazione di restrizione è impostata per consentire repository specifici, a tale restrizione verrà associato un elenco di repository consentiti corrispondente.
**Nota**
Le impostazioni di controllo dell'origine per i gruppi di pacchetti sono leggermente diverse dalle impostazioni di controllo dell'origine per i singoli pacchetti. Per ulteriori informazioni sulle impostazioni di controllo dell'origine per i pacchetti, vedere[Impostazioni di controllo dell'origine del pacchetto](package-origin-controls.md#package-origin-control-settings).
## Impostazioni di restrizione
Le impostazioni di restrizione delle impostazioni di controllo dell'origine di un gruppo di pacchetti determinano in che modo i pacchetti associati a quel gruppo possono entrare nei repository del dominio.
### PUBLISH
L'`PUBLISH`impostazione configura se le versioni dei pacchetti possono essere pubblicate direttamente in qualsiasi repository del dominio utilizzando gestori di pacchetti o strumenti simili.
+ **ALLOW**: le versioni dei pacchetti possono essere pubblicate direttamente in tutti gli archivi.
+ **BLOCK**: Le versioni dei pacchetti non possono essere pubblicate direttamente in nessun repository.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES**: le versioni dei pacchetti possono essere pubblicate direttamente solo nei repository specificati nell'elenco dei repository consentiti per la pubblicazione.
+ **INHERIT**: l'`PUBLISH`impostazione viene ereditata dal primo gruppo di pacchetti principale con un'impostazione che non lo è. `INHERIT`
### EXTERNAL\$1UPSTREAM
L'`EXTERNAL_UPSTREAM`impostazione configura se le versioni dei pacchetti possono essere importate da archivi pubblici esterni quando richiesto da un gestore di pacchetti. Per un elenco dei repository esterni supportati, vedere. [Archivi di connessioni esterne supportati](external-connection.md#supported-public-repositories)
+ **CONSENTI**: Qualsiasi versione del pacchetto può essere inserita in tutti gli archivi da una fonte pubblica con una connessione esterna.
+ **BLOCK**: Le versioni dei pacchetti non possono essere inserite in alcun repository da una fonte pubblica con una connessione esterna.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES**: le versioni dei pacchetti possono essere importate solo da una fonte pubblica nei repository specificati nell'elenco dei repository consentiti per gli upstream esterni.
+ **INHERIT: l'impostazione viene ereditata** dal primo gruppo di pacchetti principale con `EXTERNAL_UPSTREAM` un'impostazione che non lo è. `INHERIT`
### INTERNAL\$1UPSTREAM
L'`INTERNAL_UPSTREAM`impostazione configura se le versioni dei pacchetti possono essere conservate dagli archivi upstream interni nello stesso CodeArtifact dominio quando richiesto da un gestore di pacchetti.
+ **CONSENTI**: Qualsiasi versione del pacchetto può essere conservata da altri CodeArtifact repository configurati come archivi upstream.
+ **BLOCK**: Le versioni dei pacchetti non possono essere conservate da altri CodeArtifact repository configurati come repository upstream.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES: le versioni dei pacchetti possono essere conservate solo da CodeArtifact altri repository** configurati come repository upstream nei repository specificati nell'elenco dei repository consentiti per gli upstream interni.
+ **INHERIT: l'impostazione viene ereditata dal primo gruppo di pacchetti** principale con un'impostazione che non lo è`INTERNAL_UPSTREAM`. `INHERIT`
## Elenchi di repository consentiti
Quando un'impostazione di restrizione è configurata come`ALLOW_SPECIFIC_REPOSITORIES`, il gruppo di pacchetti contiene un elenco di repository consentiti che contiene un elenco di repository consentiti per tale impostazione di restrizione. Pertanto, un gruppo di pacchetti contiene da 0 a 3 elenchi di repository consentiti, uno per ogni impostazione configurata come. `ALLOW_SPECIFIC_REPOSITORIES`
Quando si aggiunge un repository all'elenco di repository consentiti di un gruppo di pacchetti, è necessario specificare a quale elenco di repository consentiti aggiungerlo.
I possibili elenchi di repository consentiti sono i seguenti:
+ `EXTERNAL_UPSTREAM`: consente o blocca l'inserimento delle versioni dei pacchetti da repository esterni nel repository aggiunto.
+ `INTERNAL_UPSTREAM`: consente o blocca l'estrazione delle versioni dei pacchetti da un altro CodeArtifact repository nel repository aggiunto.
+ `PUBLISH`: consente o blocca la pubblicazione diretta delle versioni dei pacchetti dai gestori di pacchetti nell'archivio aggiunto.
## Modifica delle impostazioni di controllo dell'origine dei gruppi di pacchetti
Per aggiungere o modificare i controlli di origine per un gruppo di pacchetti, effettuate i passaggi indicati nella procedura seguente. Per informazioni sulle impostazioni del controllo dell'origine del gruppo di pacchetti, vedere [Impostazioni di restrizione](#package-group-origin-control-settings-restrictions) e[Elenchi di repository consentiti](#package-group-origin-control-settings-repositories).
**Per aggiungere o modificare i controlli di origine dei gruppi di pacchetti (CLI)**
1. In caso contrario, configurali AWS CLI seguendo la procedura riportata di seguito. [Configurazione con AWS CodeArtifact](get-set-up-for-codeartifact.md)
1. Usa il `update-package-group-origin-configuration` comando per aggiungere o modificare i controlli di origine del pacchetto.
+ Per`--domain`, inserisci il CodeArtifact dominio che contiene il gruppo di pacchetti che desideri aggiornare.
+ Per`--domain-owner`, inserisci il numero di account del proprietario del dominio.
+ Per`--package-group`, inserisci il gruppo di pacchetti che desideri aggiornare.
+ Per`--restrictions`, inserisci coppie chiave-valore che rappresentano le restrizioni di controllo dell'origine.
+ Per`--add-allowed-repositories`, inserisci un oggetto JSON contenente il tipo di restrizione e il nome del repository da aggiungere all'elenco dei repository consentiti corrispondenti per la restrizione.
+ Ad esempio`--remove-allowed-repositories`, inserisci un oggetto JSON contenente il tipo di restrizione e il nome del repository da rimuovere dall'elenco dei repository consentiti corrispondente per la restrizione.
```
aws codeartifact update-package-group-origin-configuration \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*' \
--restrictions INTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES \
--add-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo \
--remove-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo2
```
L'esempio seguente aggiunge più restrizioni e più repository in un unico comando.
```
aws codeartifact update-package-group-origin-configuration \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*' \
--restrictions PUBLISH=BLOCK,EXTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES,INTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES \
--add-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo2 \
--remove-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo2
```
## Esempi di configurazione del controllo dell'origine dei gruppi di pacchetti
Gli esempi seguenti mostrano le configurazioni del controllo dell'origine dei pacchetti per scenari comuni di gestione dei pacchetti.
### Consentire la pubblicazione ma non l'importazione di pacchetti con nomi privati
Questo scenario è probabilmente uno scenario comune nella gestione dei pacchetti:
+ Consenti la pubblicazione di pacchetti con nomi privati nei repository del tuo dominio dai gestori di pacchetti e impedisci che vengano importati nei repository del tuo dominio da repository pubblici esterni.
+ Consenti l'importazione di tutti gli altri pacchetti nei repository del tuo dominio da archivi pubblici esterni e impedisci che vengano pubblicati nei repository del tuo dominio dai gestori di pacchetti.
**A tal fine, è necessario configurare un gruppo di pacchetti con uno schema che includa i nomi privati e le impostazioni di origine di **PUBLISH: ALLOW, **EXTERNAL\$1UPSTREAM: BLOCK e INTERNAL\$1UPSTREAM**: ALLOW**.** Ciò garantirà che i pacchetti con nomi privati possano essere pubblicati direttamente, ma non possano essere importati da repository esterni.
I seguenti AWS CLI comandi creano e configurano un gruppo di pacchetti con impostazioni di restrizione dell'origine che corrispondono al comportamento desiderato:
Per creare il gruppo di pacchetti:
```
aws codeartifact create-package-group \
--domain my_domain \
--package-group /npm/space/anycompany~ \
--domain-owner 111122223333 \
--contact-info contact@email.com | URL \
--description "my package group"
```
Per aggiornare la configurazione di origine del gruppo di pacchetti:
```
aws codeartifact update-package-group-origin-configuration \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/npm/space/anycompany~' \
--restrictions PUBLISH=ALLOW,EXTERNAL_UPSTREAM=BLOCK,INTERNAL_UPSTREAM=ALLOW
```
### Consentire l'importazione da repository esterni tramite un repository
In questo scenario, il dominio dispone di più repository. Di questi repository, `repoA` dispone di una connessione upstream a`repoB`, che dispone di una connessione esterna all'archivio pubblico, `npmjs.com` come illustrato di seguito:
`repoA --> repoB --> npmjs.com`
Si desidera consentire l'inserimento di pacchetti da un gruppo di pacchetti specifico, `/npm/space/anycompany~` da `npmjs.com` in`repoA`, ma solo tramite. `repoB` Volete anche bloccare l'inserimento dei pacchetti associati al gruppo di pacchetti in qualsiasi altro repository del vostro dominio e bloccare la pubblicazione diretta dei pacchetti con i gestori di pacchetti. A tal fine, create e configurate il gruppo di pacchetti come segue:
**Impostazioni di restrizione dell'origine di **PUBLISH: BLOCK e EXTERNAL\$1UPSTREAM:** **ALLOW\$1SPECIFIC\$1REPOSITORIES e INTERNAL\$1UPSTREAM: ALLOW\$1SPECIFIC\$1REPOSITORIES**.**
`repoA`e aggiunto all'elenco di repository consentiti appropriato: `repoB`
+ `repoA`deve essere aggiunto alla `INTERNAL_UPSTREAM` lista, in quanto riceverà i pacchetti dal suo upstream interno,. `repoB`
+ `repoB`dovrebbe essere aggiunto alla `EXTERNAL_UPSTREAM` lista, in quanto otterrà i pacchetti dal repository esterno,. `npmjs.com`
I seguenti AWS CLI comandi creano e configurano un gruppo di pacchetti con impostazioni di restrizione dell'origine che corrispondono al comportamento desiderato:
Per creare il gruppo di pacchetti:
```
aws codeartifact create-package-group \
--domain my_domain \
--package-group /npm/space/anycompany~ \
--domain-owner 111122223333 \
--contact-info contact@email.com | URL \
--description "my package group"
```
Per aggiornare la configurazione di origine del gruppo di pacchetti:
```
aws codeartifact update-package-group-origin-configuration \
--domain my_domain \
--domain-owner 111122223333 \
--package-group /npm/space/anycompany~ \
--restrictions PUBLISH=BLOCK,EXTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES,INTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES \
--add-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=repoA originRestrictionType=EXTERNAL_UPSTREAM,repositoryName=repoB
```
## In che modo le impostazioni di controllo dell'origine del gruppo di pacchetti interagiscono con le impostazioni di controllo dell'origine dei pacchetti
Poiché i pacchetti hanno impostazioni di controllo dell'origine e i gruppi di pacchetti associati hanno impostazioni di controllo dell'origine, è importante capire come queste due diverse impostazioni interagiscono tra loro. Per informazioni sull'interazione tra le impostazioni, vedere[In che modo i controlli di origine dei pacchetti interagiscono con i controlli di origine dei gruppi di pacchetti](package-origin-controls.md#package-origin-controls-interaction-package-groups).
# Sintassi della definizione del gruppo di pacchetti e comportamento di abbinamento
Questo argomento contiene informazioni sulla definizione dei gruppi di pacchetti, sul comportamento di corrispondenza dei modelli, sulla forza dell'associazione dei pacchetti e sulla gerarchia dei gruppi di pacchetti.
**Contents**
+ [Sintassi ed esempi per la definizione dei gruppi di pacchetti](#package-group-definition-syntax-examples)
+ [Definizione e normalizzazione del gruppo di pacchetti](#package-group-definition-syntax-examples-normalization)
+ [Namespace nelle definizioni dei gruppi di pacchetti](#package-group-definition-syntax-examples-namespaces)
+ [Gerarchia dei gruppi di pacchetti e specificità del modello](#package-group-hierarchy-pattern-specificity)
+ [Parole, confini delle parole e corrispondenza dei prefissi](#package-group-word-boundary-prefix)
+ [Distinzione tra lettere maiuscole e minuscole](#package-group-case-sensitivity)
+ [Partita forte e debole](#package-group-strong-and-weak-match)
+ [Varianti aggiuntive](#package-group-additional-variations)
## Sintassi ed esempi per la definizione dei gruppi di pacchetti
La sintassi del modello per definire i gruppi di pacchetti segue da vicino la formattazione dei percorsi dei pacchetti. Il percorso del pacchetto viene creato a partire dai componenti delle coordinate di un pacchetto (formato, namespace e nome) aggiungendo una barra all'inizio e separando ciascun componente con una barra. **Ad esempio, il percorso del pacchetto npm denominato *anycompany-ui-components*nello spazio dei nomi è/-ui-components. npm/space/anycompany**
Un modello di gruppo di pacchetti segue la stessa struttura di un percorso di pacchetto, tranne i componenti che non sono specificati come parte della definizione del gruppo vengono omessi e il modello termina con un suffisso. Il suffisso incluso determina il comportamento di corrispondenza del pattern, nel modo seguente:
+ Un `$` suffisso corrisponderà alla coordinata dell'intero pacchetto.
+ Un `~` suffisso corrisponderà a un prefisso.
+ Un `*` suffisso corrisponderà a tutti i valori del componente definito in precedenza.
Ecco alcuni modelli di esempio per ciascuna delle combinazioni consentite:
1. Tutti i formati di pacchetti: `/*`
1. Un formato di pacchetto specifico: `/npm/*`
1. Formato del pacchetto e prefisso dello spazio dei nomi: `/maven/com.anycompany~`
1. Formato e namespace del pacchetto: `/npm/space/*`
1. Formato del pacchetto, namespace e prefisso del nome: `/npm/space/anycompany-ui~`
1. Formato, namespace e nome del pacchetto: `/maven/org.apache.logging.log4j/log4j-core$`
Come illustrato negli esempi precedenti, il `~` suffisso viene aggiunto alla fine di uno spazio dei nomi o di un nome per rappresentare una corrispondenza di prefisso e `*` viene dopo una barra se utilizzato per abbinare tutti i valori del componente successivo nel percorso (tutti i formati, tutti gli spazi dei nomi o tutti i nomi).
### Definizione e normalizzazione del gruppo di pacchetti
CodeArtifact normalizza i NuGet nomi dei pacchetti Python e Swift e normalizza i namespace dei pacchetti Swift prima di archiviarli. CodeArtifact usa questi nomi normalizzati per abbinare i pacchetti alle definizioni dei gruppi di pacchetti. Pertanto, i gruppi di pacchetti che contengono uno spazio dei nomi o un nome in questi formati devono utilizzare lo spazio dei nomi e il nome normalizzati. [Per ulteriori informazioni su come vengono normalizzati i nomi dei pacchetti e gli spazi dei nomi, consulta la documentazione sulla normalizzazione dei nomi di [NuGet](nuget-name-normalization.md)[Python](python-name-normalization.md) e Swift.](swift-name-normalization.md)
### Namespace nelle definizioni dei gruppi di pacchetti
Per pacchetti o formati di pacchetti senza uno spazio dei nomi (Python e NuGet), i gruppi di pacchetti non devono contenere uno spazio dei nomi. La definizione del gruppo di pacchetti per questi gruppi di pacchetti contiene una sezione dello spazio dei nomi vuota. *Ad esempio, il percorso per il pacchetto Python denominato requests è */python//requests*.*
Per i pacchetti o i formati di pacchetto con uno spazio dei nomi (Maven, generic e Swift), lo spazio dei nomi deve essere incluso se è incluso il nome del pacchetto. Per il formato del pacchetto Swift, verrà utilizzato lo spazio dei nomi dei pacchetti normalizzato. Per ulteriori informazioni su come vengono normalizzati gli spazi dei nomi dei pacchetti Swift, consulta. [Normalizzazione del nome e dello spazio dei nomi del pacchetto Swift](swift-name-normalization.md)
## Gerarchia dei gruppi di pacchetti e specificità del modello
I pacchetti che sono «in» o «associati a» un gruppo di pacchetti sono pacchetti con un percorso di pacchetto che corrisponde allo schema del gruppo ma non corrisponde allo schema di un gruppo più specifico. Ad esempio, dati i gruppi di pacchetti `/npm/*` and`/npm/space/*`, il percorso del pacchetto */npm//react* è associato al primo gruppo (`/npm/*`) mentre*/npm/space/aui.components e/npm/space/amplify**-ui-core* sono associati al secondo gruppo (). `/npm/space/*` Anche se un pacchetto può corrispondere a più gruppi, ogni pacchetto è associato solo a un singolo gruppo, la corrispondenza più specifica, e solo la configurazione di un gruppo si applica al pacchetto.
Quando il percorso di un pacchetto corrisponde a più modelli, il modello «più specifico» può essere considerato il modello di corrispondenza più lungo. In alternativa, il modello più specifico è quello che corrisponde a un sottoinsieme appropriato dei pacchetti che corrispondono al modello meno specifico. Nel nostro esempio precedente, ogni pacchetto che corrisponde corrisponde `/npm/space/*` anche`/npm/*`, ma non è vero il contrario, il che rende `/npm/space/*` il modello più specifico perché è un sottoinsieme appropriato di. `/npm/*` Poiché un gruppo è un sottoinsieme di un altro gruppo, crea una gerarchia, in cui si `/npm/space/*` trova un sottogruppo del gruppo principale,. `/npm/*`
Sebbene a un pacchetto si applichi solo la configurazione del gruppo di pacchetti più specifico, tale gruppo può essere configurato per ereditare dalla configurazione del gruppo principale.
## Parole, confini delle parole e corrispondenza dei prefissi
Prima di parlare della corrispondenza dei prefissi, definiamo alcuni termini chiave:
+ Una *parola*, una lettera o un numero, seguito da zero o più lettere, numeri o caratteri distintivi (come accenti, dieresi, ecc.).
+ Un *limite di parola* si trova alla fine di una parola, quando viene raggiunto un carattere diverso da una parola. I caratteri non verbali sono caratteri di punteggiatura come, e. `.` `-` `_`
In particolare, lo schema regex di una parola è`[\p{L}\p{N}][\p{L}\p{N}\p{M}]*`, che può essere suddiviso come segue:
+ `\p{L}`rappresenta qualsiasi lettera.
+ `\p{N}`rappresenta qualsiasi numero.
+ `\p{M}`rappresenta qualsiasi carattere distintivo, ad esempio accenti, dieresi, ecc.
Pertanto, `[\p{L}\p{N}]` rappresenta un numero o una lettera e `[\p{L}\p{N}\p{M}]*` rappresenta zero o più lettere, numeri o caratteri distintivi e un limite di parola si trova alla fine di ogni corrispondenza di questo modello regex.
**Nota**
La corrispondenza dei confini delle parole si basa su questa definizione di «parola». Non si basa su parole definite in un dizionario, o CameCase. Ad esempio, non esiste alcun limite di parola in `oneword` o`OneWord`.
Ora che la parola e il limite della parola sono definiti, possiamo usarli per descrivere la corrispondenza dei prefissi in. CodeArtifact Per indicare una corrispondenza di prefisso sul confine di una parola, dopo un carattere di parola viene utilizzato un carattere di corrispondenza (`~`). Ad esempio, il modello `/npm/space/foo~` corrisponde ai percorsi dei pacchetti `/npm/space/foo` e`/npm/space/foo-bar`, ma non `/npm/space/food` a or. `/npm/space/foot`
È necessario utilizzare un carattere jolly (`*`) al posto di `~` quando si segue un carattere non verbale, come nel pattern. `/npm/*`
## Distinzione tra lettere maiuscole e minuscole
Le definizioni dei gruppi di pacchetti fanno distinzione tra maiuscole e minuscole, il che significa che modelli che differiscono solo per maiuscole e minuscole possono esistere come gruppi di pacchetti separati. Ad esempio, un utente può creare gruppi di pacchetti separati con i modelli e `/npm//asyncstorage$` per i tre pacchetti separati esistenti nel registro pubblico di npm: `/npm//AsyncStorage$``/npm//asyncStorage$`, asyncStorage *AsyncStorage*, *asyncstorage* che differiscono solo per maiuscole e *minuscole*.
Sebbene i casi siano importanti, associa CodeArtifact comunque i pacchetti a un gruppo di pacchetti se il pacchetto presenta una variazione del modello che differisce da caso a caso. Se un utente crea il gruppo di `/npm//AsyncStorage$` pacchetti senza creare gli altri due gruppi mostrati sopra, tutte le varianti maiuscole e minuscole del nome *AsyncStorage*, incluse *asyncStorage e *asyncstorage**, verranno associate al gruppo di pacchetti. Tuttavia, come descritto nella sezione successiva, queste variazioni verranno gestite in modo diverso rispetto *AsyncStorage*a[Partita forte e debole](#package-group-strong-and-weak-match), che corrisponde esattamente allo schema.
## Partita forte e debole
Le informazioni nella sezione precedente[Distinzione tra lettere maiuscole e minuscole](#package-group-case-sensitivity), affermano che i gruppi di pacchetti fanno distinzione tra maiuscole e minuscole, e poi proseguono spiegando che non fanno distinzione tra maiuscole e minuscole. Questo perché le definizioni dei gruppi di pacchetti CodeArtifact hanno un concetto di corrispondenza forte (o corrispondenza esatta) e di corrispondenza debole (o corrispondenza di variazione). Una forte corrispondenza si ha quando il pacchetto corrisponde esattamente allo schema, senza alcuna variazione. Una corrispondenza debole si verifica quando il pacchetto corrisponde a una variante dello schema, ad esempio lettere maiuscole diverse. Un comportamento di corrispondenza debole impedisce ai pacchetti che sono variazioni dello schema di un gruppo di pacchetti di passare a un gruppo di pacchetti più generale. Quando un pacchetto è una variante (weak match) del pattern del gruppo corrispondente più specifico, il pacchetto viene associato al gruppo ma il pacchetto viene bloccato invece di applicare la configurazione di controllo dell'origine del gruppo, impedendo che qualsiasi nuova versione del pacchetto venga estratta dai flussi iniziali o pubblicata. Questo comportamento riduce il rischio di attacchi alla catena di approvvigionamento derivanti dalla confusione delle dipendenze di pacchetti con nomi quasi identici.
Per illustrare un comportamento debole, supponiamo che il gruppo di pacchetti `/npm/*` consenta l'ingestione e blocchi la pubblicazione. Un gruppo di pacchetti più specifico`/npm//anycompany-spicy-client$`, è configurato per bloccare l'ingestione e consentire la pubblicazione. Il pacchetto denominato *anycompany-spicy-client*corrisponde perfettamente al gruppo di pacchetti, che consente la pubblicazione delle versioni del pacchetto e blocca l'acquisizione delle versioni del pacchetto. L'unico maiuscolo del nome del pacchetto che può essere pubblicato è *anycompany-spicy-client*, poiché corrisponde perfettamente al modello di definizione del pacchetto. Una variante diversa tra maiuscole e minuscole, come *AnyCompany-spicy-client*, è bloccata dalla pubblicazione perché non corrisponde a nulla. Ancora più importante, il gruppo di pacchetti blocca l'inserimento di tutte le varianti tra maiuscole e minuscole, non solo del nome in minuscolo utilizzato nel modello, riducendo il rischio di un attacco di confusione delle dipendenze.
## Varianti aggiuntive
Oltre alle differenze tra maiuscole e minuscole, la corrispondenza debole ignora anche le differenze nelle sequenze di trattini`-`, punti`.`, `_` trattini bassi e caratteri confondibili (ad esempio caratteri dall'aspetto simile di alfabeti separati). Durante la normalizzazione, utilizzata per la corrispondenza debole, CodeArtifact esegue la piegatura tra maiuscole e minuscole (simile alla conversione in minuscolo), sostituisce le sequenze di caratteri con trattini, punti e sottolineature con un singolo punto e normalizza i caratteri confondibili.
La corrispondenza debole considera trattini, punti e caratteri di sottolineatura come equivalenti ma non li ignora completamente. *Ciò significa che *foo-bar, foo.bar**, *foo.. bar e foo\$1bar** *sono tutti equivalenti a match deboli, ma foobar no*.* Sebbene diversi archivi pubblici implementino misure per prevenire questo tipo di variazioni, la protezione fornita dagli archivi pubblici non rende superflua questa funzionalità dei gruppi di pacchetti. *Ad esempio, gli archivi pubblici come il registro npm Public Registry impediranno nuove varianti del pacchetto denominato *my-package solo se my-package* è già stato pubblicato su di esso.* *Se *my-package è un pacchetto* interno e `/npm//my-package$` viene creato un gruppo di pacchetti che consente la pubblicazione e blocca l'ingestione, probabilmente non vorrai pubblicare *my-package nel registro pubblico di npm per impedire che una variante come my.package* sia consentita.*
Sebbene alcuni formati di pacchetti come Maven trattino questi caratteri in modo diverso (Maven lo tratta `.` come un separatore della gerarchia dei namespace ma non `-` or`_`), qualcosa come *com.act-on* potrebbe comunque essere confuso con *com.act.on*.
**Nota**
Nota che ogni volta che più varianti sono associate a un gruppo di pacchetti, un amministratore può creare un nuovo gruppo di pacchetti per una variante specifica per configurare un comportamento diverso per quella variante.
# Aggiungi un tag a un gruppo di pacchetti in CodeArtifact
I tag sono coppie chiave-valore associate a risorse AWS. Puoi applicare tag ai tuoi gruppi di pacchetti in CodeArtifact. Per informazioni sull'etichettatura CodeArtifact delle risorse, sui casi d'uso, sui vincoli di chiave e valore dei tag e sui tipi di risorse supportati, consulta. [Applicazione di tag alle risorse](tag-resources.md)
È possibile utilizzare la CLI per specificare i tag quando si crea un gruppo di pacchetti o si aggiunge, rimuove o si aggiorna il valore dei tag di un gruppo di pacchetti esistente.
## Gruppi di pacchetti di tag (CLI)
È possibile utilizzare la CLI per gestire i tag dei gruppi di pacchetti.
In caso contrario, configurali AWS CLI seguendo la procedura riportata di seguito. [Configurazione con AWS CodeArtifact](get-set-up-for-codeartifact.md)
**Suggerimento**
Per aggiungere tag, devi fornire l'Amazon Resource Name (ARN) del gruppo di pacchetti. Per ottenere l'ARN del gruppo di pacchetti, esegui il `describe-package-group` comando:
```
aws codeartifact describe-package-group \
--domain my_domain \
--package-group /npm/scope/anycompany~ \
--query packageGroup.arn
```
**Topics**
+ [Aggiungere tag a un gruppo di pacchetti (CLI)](#package-group-tags-add-cli)
+ [Visualizza i tag per un gruppo di pacchetti (CLI)](#package-group-tags-list-cli)
+ [Modifica i tag per un gruppo di pacchetti (CLI)](#package-group-tags-edit-cli)
+ [Rimuovere i tag da un gruppo di pacchetti (CLI)](#package-group-tags-delete-cli)
### Aggiungere tag a un gruppo di pacchetti (CLI)
È possibile aggiungere tag ai gruppi di pacchetti al momento della creazione o a un gruppo di pacchetti esistente. Per informazioni sull'aggiunta di tag a un gruppo di pacchetti al momento della creazione, consulta[Crea un gruppo di pacchetti](create-package-group.md).
Per aggiungere un tag a un gruppo di pacchetti esistente con AWS CLI, nel terminale o nella riga di comando, esegui il **tag-resource** comando, specificando l'Amazon Resource Name (ARN) del gruppo di pacchetti a cui desideri aggiungere i tag e la chiave e il valore del tag che desideri aggiungere. Per informazioni sul gruppo di pacchetti ARNs, consulta. [Gruppo di pacchetti ARNs](auth-and-access-control-permissions-reference.md#package-group-arns)
È possibile aggiungere più di un tag a un gruppo di pacchetti. Ad esempio, per etichettare un gruppo di pacchetti, */npm/scope/anycompany\$1* con due tag, una chiave di tag denominata *key1* con il valore del tag di *value1* e una chiave di tag denominata *key2* con il valore del tag di*value2*:
```
aws codeartifact tag-resource \
--resource-arn arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~ \
--tags key=key1,value=value1 key=key2,value=value2
```
In caso di successo, questo comando non produce alcun risultato.
### Visualizza i tag per un gruppo di pacchetti (CLI)
Segui questi passaggi per utilizzare AWS CLI per visualizzare i AWS tag per un gruppo di pacchetti. Se non sono stati aggiunti tag, l'elenco restituito è vuoto.
Nel terminale o nella riga di comando, esegui il **list-tags-for-resource** comando con l'Amazon Resource Name (ARN) del gruppo di pacchetti. Per informazioni sul gruppo di pacchetti ARNs, consulta[Gruppo di pacchetti ARNs](auth-and-access-control-permissions-reference.md#package-group-arns).
Ad esempio, per visualizzare un elenco di chiavi e valori di tag per un gruppo di pacchetti, */npm/scope/anycompany\$1* denominato con un valore ARN di `arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~`
```
aws codeartifact list-tags-for-resource \
--resource-arn arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~
```
Se il comando viene eseguito correttamente, restituisce informazioni simili alle seguenti:
```
{
"tags": {
"key1": "value1",
"key2": "value2"
}
}
```
### Modifica i tag per un gruppo di pacchetti (CLI)
Segui questi passaggi per utilizzare AWS CLI per modificare un tag per un gruppo di pacchetti. È possibile modificare il valore di una chiave esistente o aggiungere un'altra chiave. Puoi anche rimuovere i tag da un gruppo di pacchetti, come mostrato nella sezione successiva.
Nel terminale o nella riga di comando, esegui il **tag-resource** comando, specificando l'ARN del gruppo di pacchetti in cui desideri aggiornare un tag e specifica la chiave del tag e il valore del tag. Per informazioni sul gruppo di pacchetti ARNs, vedere. [Gruppo di pacchetti ARNs](auth-and-access-control-permissions-reference.md#package-group-arns)
```
aws codeartifact tag-resource \
--resource-arn arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~ \
--tags key=key1,value=newvalue1
```
In caso di successo, questo comando non produce alcun risultato.
### Rimuovere i tag da un gruppo di pacchetti (CLI)
Segui questi passaggi per AWS CLI rimuovere un tag da un gruppo di pacchetti.
**Nota**
Se elimini un gruppo di pacchetti, tutte le associazioni di tag vengono rimosse dal gruppo di pacchetti eliminato. Non è necessario rimuovere i tag prima di eliminare un gruppo di pacchetti.
Nel terminale o nella riga di comando, esegui il **untag-resource** comando, specificando l'ARN del gruppo di pacchetti in cui desideri rimuovere i tag e la chiave del tag che desideri rimuovere. Per informazioni sul gruppo di pacchetti ARNs, vedere. [Gruppo di pacchetti ARNs](auth-and-access-control-permissions-reference.md#package-group-arns)
Ad esempio, per rimuovere più tag su un gruppo di pacchetti*/npm/scope/anycompany\$1*, con le chiavi dei tag *key1* e*key2*:
```
aws codeartifact untag-resource \
--resource-arn arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~ \
--tag-keys key1 key2
```
In caso di successo, questo comando non ha alcun risultato. Dopo aver rimosso i tag, è possibile visualizzare i tag rimanenti nel gruppo di pacchetti utilizzando il `list-tags-for-resource` comando.