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à.
# Gestione di un modello Amazon Rekognition Custom Labels
Un modello Amazon Rekognition Custom Labels è un modello matematico che prevede la presenza di oggetti, scene e concetti in nuove immagini. Ciò avviene tramite individuazione di pattern nelle immagini utilizzate per addestrare il modello. Questa sezione mostra come addestrare un modello, valutarne le prestazioni e apportare miglioramenti. Mostra anche come rendere disponibile un modello all'uso e come eliminare un modello quando non è più necessario.
**Topics**
+ [Eliminazione di un modello Amazon Rekognition Custom Labels](tm-delete-model.md)
+ [Tagging di un modello](tm-tagging-model.md)
+ [Descrizione di un modello (SDK)](md-describing-model-sdk.md)
+ [Copia di un modello Amazon Rekognition Custom Labels (SDK)](md-copy-model-overview.md)
# Eliminazione di un modello Amazon Rekognition Custom Labels
Puoi eliminare un modello utilizzando la console Amazon Rekognition Custom Labels o utilizzando l'API. [DeleteProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectVersion) Non puoi eliminare un modello se è in esecuzione o in fase di addestramento. Per interrompere un modello in esecuzione, utilizza l'API. [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion) Per ulteriori informazioni, consulta [Interruzione di un modello Amazon Rekognition Custom Labels (SDK)](rm-stop.md#rm-stop-sdk). Se un modello è in fase di addestramento, attendi che finisca prima di eliminarlo.
Un modello eliminato non può essere ripristinato.
**Topics**
+ [Eliminazione di un modello Amazon Rekognition Custom Labels (console)](#tm-delete-model-console)
+ [Eliminazione di un modello Amazon Rekognition Custom Labels (SDK)](#tm-delete-model-sdk)
## Eliminazione di un modello Amazon Rekognition Custom Labels (console)
Nella seguente procedura viene illustrato come eliminare un modello da una pagina dei dettagli del progetto. Puoi anche eliminare un modello dalla pagina dei dettagli di un modello.
**Per eliminare un modello (console)**
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Scegli **Usa etichette personalizzate**.
1. Scegli **Avvia**.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**.
1. Scegli il progetto che contiene il modello che desideri eliminare. Sarà visualizzata la pagina dei dettagli del progetto.
1. Nella sezione **Modelli**, seleziona i modelli che desideri eliminare.
**Nota**
Se il modello non può essere selezionato, ciò significa che è in esecuzione o in fase di addestramento e non può essere eliminato. Controlla il campo **Stato** e riprova dopo aver interrotto il modello in esecuzione, oppure attendi il termine dell’addestramento.
1. Scegli **Elimina modello** per visualizzare la finestra di dialogo **Elimina modello**.
1. Immetti **elimina** per confermare l'eliminazione.
1. Scegli **Elimina** per eliminare il modello. Il completamento dell'eliminazione del modello potrebbe richiedere tempo.
**Nota**
Se **Chiudi** la finestra di dialogo durante l'eliminazione del modello, i modelli vengono comunque eliminati.
## Eliminazione di un modello Amazon Rekognition Custom Labels (SDK)
Puoi eliminare un modello Amazon Rekognition Custom Labels [DeleteProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectVersion)chiamando e fornendo l'Amazon Resource Name (ARN) del modello che desideri eliminare. Puoi ottenere l'ARN del modello dalla sezione **Usa il modello** della pagina dei dettagli del modello nella console di Amazon Rekognition Custom Labels. In alternativa, chiama e fornisci quanto segue [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions).
+ L’ARN del progetto (`ProjectArn`) a cui è associato il processo.
+ Il nome della versione (`VersionNames`) del modello.
Il modello ARN è il `ProjectVersionArn` campo nell'[ProjectVersionDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectVersionDescription)oggetto, dalla `DescribeProjectVersions` risposta.
Non puoi eliminare un modello se è in esecuzione o in fase di addestramento. Per determinare se il modello è in esecuzione o in fase di allenamento, chiamate [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)e controllate il `Status` campo dell'[ProjectVersionDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectVersionDescription)oggetto del modello. Per interrompere un modello in esecuzione, utilizzate l'[StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion)API. Per ulteriori informazioni, consulta [Interruzione di un modello Amazon Rekognition Custom Labels (SDK)](rm-stop.md#rm-stop-sdk). È necessario attendere che un modello finisca l'addestramento prima di poterlo eliminare.
**Per eliminare un modello (SDK)**
1. Se non l'hai già fatto, installa e configura il AWS CLI e il AWS SDKs. Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Utilizza il codice seguente per eliminare un modello.
------
#### [ AWS CLI ]
Modifica il valore di `project-version-arn` con il nome del progetto che desideri eliminare.
```
aws rekognition delete-project-version --project-version-arn model_arn \
--profile custom-labels-access
```
------
#### [ Python ]
Fornisci i seguenti parametri di riga di comando
+ `project_arn` — l'ARN del progetto che contiene il modello che desideri eliminare.
+ `model_arn` — l'ARN della versione del modello che desideri eliminare.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to delete an existing Amazon Rekognition Custom Labels model.
"""
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def find_forward_slash(input_string, n):
"""
Returns the location of '/' after n number of occurences.
:param input_string: The string you want to search
: n: the occurence that you want to find.
"""
position = input_string.find('/')
while position >= 0 and n > 1:
position = input_string.find('/', position + 1)
n -= 1
return position
def delete_model(rek_client, project_arn, model_arn):
"""
Deletes an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param model_arn: The ARN of the model version that you want to delete.
"""
try:
# Delete the model
logger.info("Deleting dataset: {%s}", model_arn)
rek_client.delete_project_version(ProjectVersionArn=model_arn)
# Get the model version name
start = find_forward_slash(model_arn, 3) + 1
end = find_forward_slash(model_arn, 4)
version_name = model_arn[start:end]
deleted = False
# model might not be deleted yet, so wait deletion finishes.
while deleted is False:
describe_response = rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
if len(describe_response['ProjectVersionDescriptions']) == 0:
deleted = True
else:
logger.info("Waiting for model deletion %s", model_arn)
time.sleep(5)
logger.info("model deleted: %s", model_arn)
return True
except ClientError as err:
logger.exception("Couldn't delete model - %s: %s",
model_arn, err.response['Error']['Message'])
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The ARN of the project that contains the model that you want to delete."
)
parser.add_argument(
"model_arn", help="The ARN of the model version that you want to delete."
)
def confirm_model_deletion(model_arn):
"""
Confirms deletion of the model. Returns True if delete entered.
:param model_arn: The ARN of the model that you want to delete.
"""
print(f"Are you sure you wany to delete model {model_arn} ?\n", model_arn)
start = input("Enter delete to delete your model: ")
if start == "delete":
return True
else:
return False
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# Get command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
if confirm_model_deletion(args.model_arn) is True:
print(f"Deleting model: {args.model_arn}")
# Delete the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
delete_model(rekognition_client,
args.project_arn,
args.model_arn)
print(f"Finished deleting model: {args.model_arn}")
else:
print(f"Not deleting model {args.model_arn}")
except ClientError as err:
print(f"Problem deleting model: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
+ `project_arn` — l'ARN del progetto che contiene il modello che desideri eliminare.
+ `model_arn` — l'ARN della versione del modello che desideri eliminare.
```
//Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-custom-labels-developer-guide/blob/master/LICENSE-SAMPLECODE.)
import java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DeleteProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.DeleteProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class DeleteModel {
public static final Logger logger = Logger.getLogger(DeleteModel.class.getName());
public static int findForwardSlash(String modelArn, int n) {
int start = modelArn.indexOf('/');
while (start >= 0 && n > 1) {
start = modelArn.indexOf('/', start + 1);
n -= 1;
}
return start;
}
public static void deleteMyModel(RekognitionClient rekClient, String projectArn, String modelArn)
throws InterruptedException {
try {
logger.log(Level.INFO, "Deleting model: {0}", projectArn);
// Delete the model
DeleteProjectVersionRequest deleteProjectVersionRequest = DeleteProjectVersionRequest.builder()
.projectVersionArn(modelArn).build();
DeleteProjectVersionResponse response =
rekClient.deleteProjectVersion(deleteProjectVersionRequest);
logger.log(Level.INFO, "Status: {0}", response.status());
// Get the model version
int start = findForwardSlash(modelArn, 3) + 1;
int end = findForwardSlash(modelArn, 4);
String versionName = modelArn.substring(start, end);
Boolean deleted = false;
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.projectArn(projectArn).versionNames(versionName).build();
// Wait until model is deleted.
do {
DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
.describeProjectVersions(describeProjectVersionsRequest);
if (describeProjectVersionsResponse.projectVersionDescriptions().size()==0) {
logger.log(Level.INFO, "Waiting for model deletion: {0}", modelArn);
Thread.sleep(5000);
} else {
deleted = true;
logger.log(Level.INFO, "Model deleted: {0}", modelArn);
}
} while (Boolean.FALSE.equals(deleted));
logger.log(Level.INFO, "Model deleted: {0}", modelArn);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project that contains the model that you want to delete.\n\n"
+ " model_version - The ARN of the model that you want to delete.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
String projectArn = args[0];
String modelVersion = args[1];
try {
RekognitionClient rekClient = RekognitionClient.builder().build();
// Delete the model
deleteMyModel(rekClient, projectArn, modelVersion);
System.out.println(String.format("model deleted: %s", modelVersion));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
catch (InterruptedException intError) {
logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------
# Tagging di un modello
Puoi identificare, organizzare, cercare e filtrare i modelli Amazon Rekognition utilizzando tag. Ogni tag è un'etichetta composta da una chiave e un valore definiti dall'utente. Ad esempio, per determinare la fatturazione per i modelli, contrassegna i modelli con una chiave `Cost center` e aggiungi il numero del centro di costo appropriato come valore. Per ulteriori informazioni, consulta [Tagging di risorse AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Usa i tag per:
+ Tenere traccia della fatturazione per un modello utilizzando i tag di allocazione dei costi. Per ulteriori informazioni, consulta [Utilizzo dei tag per l'allocazione dei costi](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html).
+ Controllare l’accesso a un modello tramite AWS Identity and Access Management (IAM). Per ulteriori informazioni, consulta [Controllo dell'accesso alle risorse AWS mediante i tag delle risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html).
+ Automatizzare la gestione dei modelli. Ad esempio, è possibile eseguire script di avvio o arresto automatizzati che disattivano gli ambienti di sviluppo durante le ore non lavorative per ridurre i costi. Per ulteriori informazioni, consulta [Esecuzione di un modello Amazon Rekognition Custom Labels addestrato](running-model.md).
Puoi etichettare i modelli utilizzando la console Amazon Rekognition o utilizzando il. AWS SDKs
**Topics**
+ [Tagging dei modelli (console)](#tm-tagging-model-console)
+ [Visualizzazione dei tag del modello](#tm-tagging-model-viewing-console)
+ [Tagging dei modelli (SDK)](#tm-tagging-model-sdk)
## Tagging dei modelli (console)
Puoi utilizzare la console di Rekognition per aggiungere tag ai modelli, visualizzare i tag associati a un modello e rimuovere tag.
### Aggiunta e rimozione di tag
Questa procedura spiega come aggiungere o rimuovere tag da un modello esistente. È possibile aggiungere i tag a un nuovo modello durante l'addestramento. Per ulteriori informazioni, consulta [Addestramento di un modello Amazon Rekognition Custom Labels](training-model.md).
**Per aggiungere o rimuovere tag da un modello esistente utilizzando la console**
1. Apri la console Amazon Rekognition all'indirizzo. [ https://console.aws.amazon.com/rekognition/]( https://console.aws.amazon.com/rekognition/)
1. Scegli **Avvia**.
1. Nel riquadro di navigazione selezionare **Progetti**.
1. Nella pagina **Progetti**, scegli il progetto contenente il modello a cui desideri attribuire tag.
1. Nel pannello di navigazione, sotto il progetto scelto in precedenza, scegli **Modelli**.
1. Nella sezione **Modelli**, scegli il modello a cui vuoi aggiungere un tag.
1. Nella pagina dei dettagli del modello, seleziona la scheda **Tag** .
1. Nella sezione **Tag** scegli **Gestisci tag**.
1. Nella pagina **Gestisci tag**, scegli **Aggiungi nuovo tag**.
1. Immetti una chiave e un valore.
1. In **Chiave**, immettere un nome per la chiave.
1. Per **Value (Valore)**, immetti un valore.
1. Ripeti i passaggi 9 e 10 per aggiungere altri tag.
1. (Facoltativo) Per rimuovere un tag, scegli **Rimuovi** accanto al tag da rimuovere. Se stai rimuovendo un tag salvato in precedenza, questo viene rimosso quando salvi le modifiche.
1. Per salvare le modifiche, scegliere **Salva modifiche**.
## Visualizzazione dei tag del modello
Puoi utilizzare la console di Amazon Rekognition per visualizzare i tag associati a un modello.
Per visualizzare i tag associati a *tutti i modelli all'interno di un progetto*, devi utilizzare l'SDK AWS. Per ulteriori informazioni, consulta [Elencare i tag di un modello](#listing-model-tags-sdk).
**Per visualizzare i tag associati a un modello**
1. Apri la console Amazon Rekognition all'indirizzo. [ https://console.aws.amazon.com/rekognition/]( https://console.aws.amazon.com/rekognition/)
1. Scegli **Avvia**.
1. Nel riquadro di navigazione selezionare **Progetti**.
1. Nella pagina delle risorse **Progetti**, scegli il progetto che contiene il modello di cui desideri visualizzare il tag.
1. Nel pannello di navigazione, sotto il progetto scelto in precedenza, scegli **Modelli**.
1. Nella sezione **Modelli**, scegli il modello di cui desideri visualizzare l'etichetta.
1. Nella pagina dei dettagli del modello, seleziona la scheda **Tag** . I tag sono mostrati nella sezione **Tag**.
## Tagging dei modelli (SDK)
Puoi utilizzare l'SDK per: AWS
+ Aggiungere tag a un nuovo modello
+ Aggiungere tag a un modello esistente
+ Elencare i tag associati a un modello
+ Rimuovere tag da un modello
I tag negli AWS CLI esempi seguenti hanno il seguente formato.
```
--tags '{"key1":"value1","key2":"value2"}'
```
In alternativa, puoi utilizzare questo formato.
```
--tags key1=value1,key2=value2
```
Se non hai installato il AWS CLI, consulta[Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
### Aggiungere tag a un nuovo modello
È possibile aggiungere tag a un modello quando lo si crea utilizzando l'[CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion.html)operazione. Specifica uno o più tag nel parametro di input dell'array `Tags`.
```
aws rekognition create-project-version --project-arn project arn \
--version-name version_name \
--output-config '{ "S3Location": { "Bucket": "output bucket", "Prefix": "output folder" } }' \
--tags '{"key1":"value1","key2":"value2"}' \
--profile custom-labels-access
```
Per ulteriori informazioni sulla creazione e sull’addestramento di un modello, consulta [Addestramento di un modello (SDK)](training-model.md#tm-sdk).
### Aggiungere tag a un modello esistente
Per aggiungere uno o più tag a un modello esistente, utilizzate l'[TagResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TagResource)operazione. Specifica l'Amazon Resource Name (ARN) del modello (`ResourceArn`) i tag (`Tags`) da aggiungere. L'esempio seguente mostra come aggiungere due tag.
```
aws rekognition tag-resource --resource-arn resource-arn \
--tags '{"key1":"value1","key2":"value2"}' \
--profile custom-labels-access
```
Puoi ottenere l'ARN di un modello chiamando. [CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion)
### Elencare i tag di un modello
Per elencare i tag allegati a un modello, utilizzate l'[ListTagsForResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListTagsForResource)operazione e specificate l'ARN del modello ()`ResourceArn`. La risposta è una mappa di chiavi e valori di tag associati a un modello specificato.
```
aws rekognition list-tags-for-resource --resource-arn resource-arn \
--profile custom-labels-access
```
L'output visualizza un elenco dei tag collegati al modello.
```
{
"Tags": {
"Dept": "Engineering",
"Name": "Ana Silva Carolina",
"Role": "Developer"
}
}
```
Per vedere quali modelli di un progetto hanno un tag specifico, chiama `DescribeProjectVersions` per ottenere un elenco di modelli. Quindi chiama `ListTagsForResource` per ogni modello nella risposta da `DescribeProjectVersions`. Controlla la risposta da `ListTagsForResource` per vedere se è presente il tag richiesto.
Il seguente esempio Python 3 mostra come cercare una chiave e un valore di tag specifici in tutti i tuoi progetti. L'output include l'ARN del progetto e l'ARN del modello in cui viene trovata una chiave corrispondente.
**Per cercare un valore di tag**
1. Salva il seguente codice in un file denominato `find_tag.py`.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to find a tag value that's associated with models within
your Amazon Rekognition Custom Labels projects.
"""
import logging
import argparse
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def find_tag_in_projects(rekognition_client, key, value):
"""
Finds Amazon Rekognition Custom Label models tagged with the supplied key and key value.
:param rekognition_client: An Amazon Rekognition boto3 client.
:param key: The tag key to find.
:param value: The value of the tag that you want to find.
return: A list of matching model versions (and model projects) that were found.
"""
try:
found_tags = []
found = False
projects = rekognition_client.describe_projects()
# Iterate through each project and models within a project.
for project in projects["ProjectDescriptions"]:
logger.info("Searching project: %s ...", project["ProjectArn"])
models = rekognition_client.describe_project_versions(
ProjectArn=(project["ProjectArn"])
)
for model in models["ProjectVersionDescriptions"]:
logger.info("Searching model %s", model["ProjectVersionArn"])
tags = rekognition_client.list_tags_for_resource(
ResourceArn=model["ProjectVersionArn"]
)
logger.info(
"\tSearching model: %s for tag: %s value: %s.",
model["ProjectVersionArn"],
key,
value,
)
# Check if tag exists.
if key in tags["Tags"]:
if tags["Tags"][key] == value:
found = True
logger.info(
"\t\tMATCH: Project: %s: model version %s",
project["ProjectArn"],
model["ProjectVersionArn"],
)
found_tags.append(
{
"Project": project["ProjectArn"],
"ModelVersion": model["ProjectVersionArn"],
}
)
if found is False:
logger.info("No match for Tag %s with value %s.", key, value)
return found_tags
except ClientError as err:
logger.info("Problem finding tags: %s. ", format(err))
raise
def main():
"""
Entry point for example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
# Set up command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
parser.add_argument("tag", help="The tag that you want to find.")
parser.add_argument("value", help="The tag value that you want to find.")
args = parser.parse_args()
key = args.tag
value = args.value
print(f"Searching your models for tag: {key} with value: {value}.")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Get tagged models for all projects.
tagged_models = find_tag_in_projects(rekognition_client, key, value)
print("Matched models\n--------------")
if len(tagged_models) > 0:
for model in tagged_models:
print(
"Project: {project}\nModel version: {version}\n".format(
project=model["Project"], version=model["ModelVersion"]
)
)
else:
print("No matches found.")
print("Done.")
if __name__ == "__main__":
main()
```
1. Nel prompt dei comandi inserisci quanto segue. Sostituite *key* e *value* con il nome della chiave e il valore della chiave che desiderate trovare.
```
python find_tag.py key value
```
### Eliminazione di tag da un modello
Per rimuovere uno o più tag da un modello, utilizzate l'[UntagResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UntagResource)operazione. Specifica l'ARN del modello (`ResourceArn`) e le chiavi del tag (`Tag-Keys`) che desideri rimuovere.
```
aws rekognition untag-resource --resource-arn resource-arn \
--tag-keys '["key1","key2"]' \
--profile custom-labels-access
```
In alternativa, puoi specificare `tag-keys` in questo formato.
```
--tag-keys key1,key2
```
# Descrizione di un modello (SDK)
È possibile utilizzare l'API `DescribeProjectVersions` per ottenere informazioni su una versione di un modello. Se non lo specifichi `VersionName`, `DescribeProjectVersions` restituisce descrizioni per tutte le versioni del modello nel progetto.
**Per descrivere un modello (SDK)**
1. Se non l'hai ancora fatto, installa e configura il AWS CLI AWS SDKs. Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Utilizza il seguente codice di esempio per descrivere una versione di un modello.
------
#### [ AWS CLI ]
Modifica il valore di `project-arn` con l’ARN del progetto che desideri descrivere. Cambia il valore di `version-name` nella versione del modello che desideri descrivere.
```
aws rekognition describe-project-versions --project-arn project_arn \
--version-names version_name \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ project\$1arn — l'ARN del modello che desideri descrivere.
+ model\$1version — la versione del modello che desideri descrivere.
Ad esempio: `python describe_model.py project_arn model_version `
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to describe an Amazon Rekognition Custom Labels model.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def describe_model(rek_client, project_arn, version_name):
"""
Describes an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the prject that contains the model.
:param version_name: The version name of the model that you want to describe.
"""
try:
# Describe the model
logger.info("Describing model: %s for project %s",
version_name, project_arn)
describe_response = rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
for model in describe_response['ProjectVersionDescriptions']:
print(f"Created: {str(model['CreationTimestamp'])} ")
print(f"ARN: {str(model['ProjectVersionArn'])} ")
if 'BillableTrainingTimeInSeconds' in model:
print(
f"Billing training time (minutes): {str(model['BillableTrainingTimeInSeconds']/60)} ")
print("Evaluation results: ")
if 'EvaluationResult' in model:
evaluation_results = model['EvaluationResult']
print(f"\tF1 score: {str(evaluation_results['F1Score'])}")
print(
f"\tSummary location: s3://{evaluation_results['Summary']['S3Object']['Bucket']}/{evaluation_results['Summary']['S3Object']['Name']}")
if 'ManifestSummary' in model:
print(
f"Manifest summary location: s3://{model['ManifestSummary']['S3Object']['Bucket']}/{model['ManifestSummary']['S3Object']['Name']}")
if 'OutputConfig' in model:
print(
f"Training output location: s3://{model['OutputConfig']['S3Bucket']}/{model['OutputConfig']['S3KeyPrefix']}")
if 'MinInferenceUnits' in model:
print(
f"Minimum inference units: {str(model['MinInferenceUnits'])}")
if 'MaxInferenceUnits' in model:
print(
f"Maximum Inference units: {str(model['MaxInferenceUnits'])}")
print("Status: " + model['Status'])
print("Message: " + model['StatusMessage'])
except ClientError as err:
logger.exception(
"Couldn't describe model: %s", err.response['Error']['Message'])
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The ARN of the project in which the model resides."
)
parser.add_argument(
"version_name", help="The version of the model that you want to describe."
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# Get command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
print(
f"Describing model: {args.version_name} for project {args.project_arn}.")
# Describe the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
describe_model(rekognition_client, args.project_arn,
args.version_name)
print(
f"Finished describing model: {args.version_name} for project {args.project_arn}.")
except ClientError as err:
error_message = f"Problem describing model: {err}"
logger.exception(error_message)
print(error_message)
except Exception as err:
error_message = f"Problem describing model: {err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ project\$1arn — l'ARN del modello che desideri descrivere.
+ model\$1version — la versione del modello che desideri descrivere.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.EvaluationResult;
import software.amazon.awssdk.services.rekognition.model.GroundTruthManifest;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class DescribeModel {
public static final Logger logger = Logger.getLogger(DescribeModel.class.getName());
public static void describeMyModel(RekognitionClient rekClient, String projectArn, String versionName) {
try {
// If a single version name is supplied, build request argument
DescribeProjectVersionsRequest describeProjectVersionsRequest = null;
if (versionName == null) {
describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder().projectArn(projectArn)
.build();
} else {
describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder().projectArn(projectArn)
.versionNames(versionName).build();
}
DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
.describeProjectVersions(describeProjectVersionsRequest);
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
System.out.println("ARN: " + projectVersionDescription.projectVersionArn());
System.out.println("Status: " + projectVersionDescription.statusAsString());
System.out.println("Message: " + projectVersionDescription.statusMessage());
if (projectVersionDescription.billableTrainingTimeInSeconds() != null) {
System.out.println(
"Billable minutes: " + (projectVersionDescription.billableTrainingTimeInSeconds() / 60));
}
if (projectVersionDescription.evaluationResult() != null) {
EvaluationResult evaluationResult = projectVersionDescription.evaluationResult();
System.out.println("F1 Score: " + evaluationResult.f1Score());
System.out.println("Summary location: s3://" + evaluationResult.summary().s3Object().bucket() + "/"
+ evaluationResult.summary().s3Object().name());
}
if (projectVersionDescription.manifestSummary() != null) {
GroundTruthManifest manifestSummary = projectVersionDescription.manifestSummary();
System.out.println("Manifest summary location: s3://" + manifestSummary.s3Object().bucket() + "/"
+ manifestSummary.s3Object().name());
}
if (projectVersionDescription.outputConfig() != null) {
OutputConfig outputConfig = projectVersionDescription.outputConfig();
System.out.println(
"Training output: s3://" + outputConfig.s3Bucket() + "/" + outputConfig.s3KeyPrefix());
}
if (projectVersionDescription.minInferenceUnits() != null) {
System.out.println("Min inference units: " + projectVersionDescription.minInferenceUnits());
}
System.out.println();
}
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
throw rekError;
}
}
public static void main(String args[]) {
String projectArn = null;
String versionName = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project that contains the models you want to describe.\n\n"
+ " version_name - (optional) The version name of the model that you want to describe. \n\n"
+ " If you don't specify a value, all model versions are described.\n\n";
if (args.length > 2 || args.length == 0) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
if (args.length == 2) {
versionName = args[1];
}
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Describe the model
describeMyModel(rekClient, projectArn, versionName);
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Copia di un modello Amazon Rekognition Custom Labels (SDK)
Puoi utilizzare l'[CopyProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CopyProjectVersion)operazione per copiare una versione del modello Amazon Rekognition Custom Labels da un progetto Amazon Rekognition Custom Labels di origine a un progetto di destinazione. Il progetto di destinazione può trovarsi in un AWS account diverso o nello stesso account. AWS Uno scenario tipico consiste nel copiare un modello testato da un account di sviluppo a un AWS AWS account di produzione.
In alternativa, puoi addestrare il modello nell'account di destinazione con il set di dati di origine. L'utilizzo dell'operazione `CopyProjectVersion` ha i vantaggi seguenti.
+ Il comportamento del modello è coerente. L'addestramento dei modelli non è deterministico e non è garantito che due modelli addestrati con lo stesso set di dati effettuino le stesse previsioni. La copia del modello con `CopyProjectVersion` aiuta a garantire che il comportamento del modello copiato sia coerente con il modello di origine e non sia necessario ripetere il test del modello.
+ Non è richiesto addestramento del modello. In questo modo puoi risparmiare denaro poiché ti viene addebitato un costo per ogni addestramento con esito positivo di un modello.
Per copiare un modello su un altro AWS account, devi avere un progetto Amazon Rekognition Custom Labels nell'account di destinazione. AWS Per informazioni sulla creazione di un progetto, consultare [Creare un progetto](mp-create-project.md). Assicurati di creare il progetto nell'account di destinazione. AWS
Una [policy di progetto](md-create-project-policy-document.md) è una policy basata su risorse che imposta le autorizzazioni di copia per la versione del modello che desideri copiare. È necessario utilizzare una [politica di progetto](md-create-project-policy-document.md) quando il progetto di destinazione si trova in un AWS account diverso dal progetto di origine.
Non è necessario utilizzare una [policy di progetto](md-create-project-policy-document.md) quando si copiano le versioni del modello all'interno dello stesso account. Tuttavia, puoi scegliere di utilizzare una [policy di progetto](md-create-project-policy-document.md) sui progetti inter-account se desideri un maggiore controllo su queste risorse.
È possibile allegare la politica del progetto al progetto di origine richiamando l'[PutProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PutProjectPolicy)operazione.
Non è possibile utilizzare `CopyProjectVersion` per copiare un modello in un progetto in una AWS regione diversa. Inoltre, non puoi copiare un modello con la console di Amazon Rekognition Custom Labels. In questi casi, puoi addestrare il modello nel progetto di destinazione con i set di dati utilizzati per addestrare il modello sorgente. Per ulteriori informazioni, consulta [Addestramento di un modello Amazon Rekognition Custom Labels](training-model.md).
Per copiare un modello da un progetto di origine a un progetto di destinazione, procedi come segue:
**Per copiare un modello**
1. [Crea un documento sulla policy del progetto](md-create-project-policy-document.md).
1. [Collega la policy del progetto al progetto di origine](md-attach-project-policy.md).
1. [Copia il modello con l'operazione `CopyProjectVersion`](md-copy-model-sdk.md).
Per rimuovere una politica di progetto da un progetto, chiama [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy). Per ottenere un elenco delle politiche di progetto allegate a un progetto, chiama [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
**Topics**
+ [Creazione di un documento di policy](md-create-project-policy-document.md)
+ [Collegare una policy di progetto (SDK)](md-attach-project-policy.md)
+ [Copia di un modello (SDK)](md-copy-model-sdk.md)
+ [Elenco delle policy del progetto (SDK)](md-list-project-policies.md)
+ [Eliminazione di una policy di progetto (SDK)](md-delete-project-policy.title.md)
# Creazione di un documento di policy
Rekognition Custom Labels utilizza una policy basata su risorse, nota come *policy di progetto*, per gestire le autorizzazioni di copia per una versione del modello. Una policy di progetto è un documento in formato JSON.
Una policy di progetto consente o nega un'autorizzazione [principale](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html#intro-structure-principal) a copiare una versione del modello da un progetto di origine a un progetto di destinazione. È necessaria una politica di progetto se il progetto di destinazione si trova in un AWS account diverso. Ciò vale anche se il progetto di destinazione si trova nello stesso account AWS del progetto di origine e desideri limitare l'accesso a versioni specifiche del modello. Ad esempio, potresti voler negare le autorizzazioni di copia a uno specifico ruolo IAM all'interno di un AWS account.
L'esempio seguente consente al principale `arn:aws:iam::111111111111:role/Admin` di copiare la versione del modello `arn:aws:rekognition:us-east-1:123456789012:project/my_project/version/test_1/1627045542080`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"AWS":"arn:aws:iam::111111111111:role/Admin"
},
"Action":"rekognition:CopyProjectVersion",
"Resource":"arn:aws:rekognition:us-east-1:111111111111:project/my_project/version/test_1/1627045542080"
}
]
}
```
------
**Nota**
`Action`, `Resource`, `Principal` e `Effect` sono campi obbligatori in un documento sulla policy del progetto.
L’unico `action` supportato è `rekognition:CopyProjectVersion`.
`NotAction`, `NotResource`, e `NotPrincipal` sono campi proibiti e non devono essere presenti nel documento sulla policy del progetto.
Se non specifichi una politica di progetto, un responsabile dello stesso AWS account del progetto di origine può comunque copiare un modello, se il responsabile ha una politica basata sull'identità, ad esempio che autorizza la ` AmazonRekognitionCustomLabelsFullAccess` chiamata. `CopyProjectVersion`
La procedura seguente crea un file di documento sulle policy di progetto che è possibile utilizzare con l'esempio Python in [Collegare una policy di progetto (SDK)](md-attach-project-policy.md). Se si utilizza il `put-project-policy` AWS CLI comando, si fornisce la politica del progetto come stringa JSON.
**Creazione di un documento sulla policy di progetto**
1. In un editor di testo, crea il seguente documento. Imposta i valori seguenti:
+ Effetto – Specifica `ALLOW` per concedere l'autorizzazione alla copia. Specifica `DENY` per negare l'autorizzazione alla copia.
+ Principale – Per il principale al quale intendi consentire o negare l'accesso alle versioni del modello specificate in `Resource`. Ad esempio, puoi specificare l'[account principal AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#principal-accounts) per un AWS account diverso. Non limitiamo i principali che puoi utilizzare. Per ulteriori informazioni, consulta [Specifica di un principale](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#Principal_specifying).
+ Risorsa – L’Amazon Resource Name (ARN) della versione del modello per la quale intendi specificare le autorizzazioni di copia. Se desideri concedere le autorizzazioni a tutte le versioni del modello all'interno del progetto di origine, utilizza il seguente formato `arn:aws:rekognition:region:account:project/source project/version/* `
1. Salva la policy del progetto nel computer.
1. Collega la policy del progetto al progetto sorgente seguendo le istruzioni in [Collegare una policy di progetto (SDK)](md-attach-project-policy.md).
# Collegare una policy di progetto (SDK)
Alleghi una policy di progetto a un progetto Amazon Rekognition Custom Labels chiamando l'operazione. [PutProjectpolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PutProjectPolicy)
Collega più policy di progetto a un progetto chiamando `PutProjectPolicy` per ogni policy di progetto che desideri aggiungere. Puoi collegare fino a cinque policy di progetto a un progetto. Se hai bisogno di collegare più policy di progetto, puoi richiedere un aumento del [limite](limits.md).
Quando alleghi per la prima volta una policy di progetto specifica a un progetto, non specificare un ID di revisione nel parametro di input `PolicyRevisionId`. Il modulo di risposta `PutProjectPolicy` è un ID di revisione per la policy di progetto che Amazon Rekognition Custom Labels crea per te. Puoi utilizzare l'ID di revisione per aggiornare o eliminare l'ultima revisione di una policy di progetto. Amazon Rekognition Custom Labels conserva solo l'ultima revisione delle policy di progetto. Se tenti di aggiornare o eliminare una revisione precedente di una policy di progetto, ricevi un errore `InvalidPolicyRevisionIdException`.
Per aggiornare una policy di progetto esistente, specifica l'ID di revisione della policy di progetto nel parametro di input `PolicyRevisionId`. Puoi ottenere la revisione IDs delle politiche di progetto in un progetto chiamando. [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)
Dopo aver associato una policy di progetto a un progetto di origine, è possibile copiare il modello dal progetto di origine al progetto di destinazione. Per ulteriori informazioni, consulta [Copia di un modello (SDK)](md-copy-model-sdk.md).
Per rimuovere una politica di progetto da un progetto, chiama [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy). Per ottenere un elenco delle politiche di progetto allegate a un progetto, chiama [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
**Per collegare una policy di progetto a un progetto (SDK)**
1. Se non l'hai già fatto, installa e configura il AWS CLI AWS SDKs. Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. [Crea un documento sulla policy del progetto](md-create-project-policy-document.md).
1. Usa il codice seguente per allegare la politica del progetto al progetto, nell' AWS account di fiducia, che contiene la versione del modello che desideri copiare. Per ottenere l'ARN del progetto, chiama. [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-describing-project-sdk.html) Per ottenere la versione del modello, chiamate ARN. [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-describing-model-sdk.html)
------
#### [ AWS CLI ]
Imposta i valori seguenti:
+ `project-arn`all'ARN del progetto di origine nell' AWS account di fiducia che contiene la versione del modello che si desidera copiare.
+ `policy-name` a un nome di policy a tua scelta.
+ `principal` al principale a cui desiderate consentire o negare l'accesso alle versioni del modello specificate in `Model version ARN`.
+ `project-version-arn` all'ARN della versione del modello che desideri copiare.
Se desideri aggiornare una policy di progetto esistente, specifica il parametro `policy-revision-id` e fornisci l'ID di revisione della policy di progetto desiderata.
```
aws rekognition put-project-policy \
--project-arn project-arn \
--policy-name policy-name \
--policy-document '{ "Version": "2012-10-17", "Statement":[{ "Effect":"ALLOW or DENY", "Principal":{ "AWS":"principal" }, "Action":"rekognition:CopyProjectVersion", "Resource":"project-version-arn" }]}' \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `project_arn` — L'ARN del progetto di origine a cui desideri collegare la policy del progetto.
+ `policy_name` — Un nome di policy a tua scelta.
+ `project_policy` — Il file che contiene il documento sulla policy del progetto.
+ `policy_revision_id` — (facoltativo). Se desideri aggiornare una revisione esistente di una policy di progetto, specifica l'ID di revisione della policy di progetto.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Amazon Rekognition Custom Labels model example used in the service documentation:
https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-copy-model-sdk.html
Shows how to attach a project policy to an Amazon Rekognition Custom Labels project.
"""
import boto3
import argparse
import logging
import json
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def put_project_policy(rek_client, project_arn, policy_name, policy_document_file, policy_revision_id=None):
"""
Attaches a project policy to an Amazon Rekognition Custom Labels project.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param policy_name: A name for the project policy.
:param project_arn: The Amazon Resource Name (ARN) of the source project
that you want to attach the project policy to.
:param policy_document_file: The JSON project policy document to
attach to the source project.
:param policy_revision_id: (Optional) The revision of an existing policy to update.
Pass None to attach new policy.
:return The revision ID for the project policy.
"""
try:
policy_document_json = ""
response = None
with open(policy_document_file, 'r') as policy_document:
policy_document_json = json.dumps(json.load(policy_document))
logger.info(
"Attaching %s project_policy to project %s.",
policy_name, project_arn)
if policy_revision_id is None:
response = rek_client.put_project_policy(ProjectArn=project_arn,
PolicyName=policy_name,
PolicyDocument=policy_document_json)
else:
response = rek_client.put_project_policy(ProjectArn=project_arn,
PolicyName=policy_name,
PolicyDocument=policy_document_json,
PolicyRevisionId=policy_revision_id)
new_revision_id = response['PolicyRevisionId']
logger.info(
"Finished creating project policy %s. Revision ID: %s",
policy_name, new_revision_id)
return new_revision_id
except ClientError as err:
logger.exception(
"Couldn't attach %s project policy to project %s: %s }",
policy_name, project_arn, err.response['Error']['Message'] )
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The Amazon Resource Name (ARN) of the project "
"that you want to attach the project policy to."
)
parser.add_argument(
"policy_name", help="A name for the project policy."
)
parser.add_argument(
"project_policy", help="The file containing the project policy JSON"
)
parser.add_argument(
"--policy_revision_id", help="The revision of an existing policy to update. "
"If you don't supply a value, a new project policy is created.",
required=False
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# get command line arguments
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
print(f"Attaching policy to {args.project_arn}")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Attach a new policy or update an existing policy.
response = put_project_policy(rekognition_client,
args.project_arn,
args.policy_name,
args.project_policy,
args.policy_revision_id)
print(
f"project policy {args.policy_name} attached to project {args.project_arn}")
print(f"Revision ID: {response}")
except ClientError as err:
print("Problem attaching project policy: %s", err)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `project_arn` — L'ARN del progetto di origine a cui desideri collegare la policy del progetto.
+ `project_policy_name` — Un nome di policy a tua scelta.
+ `project_policy_document` — Il file che contiene il documento sulla policy del progetto.
+ `project_policy_revision_id` — (facoltativo). Se desideri aggiornare una revisione esistente di una policy di progetto, specifica l'ID di revisione della policy di progetto.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.logging.Level;
import java.util.logging.Logger;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.PutProjectPolicyRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class PutProjectPolicy {
public static final Logger logger = Logger.getLogger(PutProjectPolicy.class.getName());
public static void putMyProjectPolicy(RekognitionClient rekClient, String projectArn, String projectPolicyName,
String projectPolicyFileName, String projectPolicyRevisionId) throws IOException {
try {
Path filePath = Path.of(projectPolicyFileName);
String policyDocument = Files.readString(filePath);
String[] logArguments = new String[] { projectPolicyFileName, projectPolicyName };
PutProjectPolicyRequest putProjectPolicyRequest = null;
logger.log(Level.INFO, "Attaching Project policy: {0} to project: {1}", logArguments);
// Attach the project policy.
if (projectPolicyRevisionId == null) {
putProjectPolicyRequest = PutProjectPolicyRequest.builder().projectArn(projectArn)
.policyName(projectPolicyName).policyDocument(policyDocument).build();
} else {
putProjectPolicyRequest = PutProjectPolicyRequest.builder().projectArn(projectArn)
.policyName(projectPolicyName).policyRevisionId(projectPolicyRevisionId)
.policyDocument(policyDocument)
.build();
}
rekClient.putProjectPolicy(putProjectPolicyRequest);
logger.log(Level.INFO, "Attached Project policy: {0} to project: {1}", logArguments);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: "
+ " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project that you want to attach the project policy to.\n\n"
+ " project_policy_name - A name for the project policy.\n\n"
+ " project_policy_document - The file name of the project policy.\n\n"
+ " project_policy_revision_id - (Optional) The revision ID of the project policy that you want to update.\n\n";
if (args.length < 3 || args.length > 4) {
System.out.println(USAGE);
System.exit(1);
}
String projectArn = args[0];
String projectPolicyName = args[1];
String projectPolicyDocument = args[2];
String projectPolicyRevisionId = null;
if (args.length == 4) {
projectPolicyRevisionId = args[3];
}
try {
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Attach the project policy.
putMyProjectPolicy(rekClient, projectArn, projectPolicyName, projectPolicyDocument,
projectPolicyRevisionId);
System.out.println(
String.format("project policy %s: attached to project: %s", projectPolicyName, projectArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
catch (IOException intError) {
logger.log(Level.SEVERE, "Exception while reading policy document: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------
1. Copia la versione del modello seguendo le istruzioni riportate in [Copia di un modello (SDK)](md-copy-model-sdk.md).
# Copia di un modello (SDK)
È possibile utilizzare l'API `CopyProjectVersion` per copiare una versione del modello da un progetto di origine a un progetto di destinazione. Il progetto di destinazione può trovarsi in un AWS account diverso ma deve appartenere alla stessa AWS regione. Se il progetto di destinazione si trova in un AWS account diverso (o se si desidera concedere autorizzazioni specifiche per una versione del modello copiata all'interno di un AWS account), è necessario allegare una politica di progetto al progetto di origine. Per ulteriori informazioni, consulta [Creazione di un documento di policy](md-create-project-policy-document.md). L'API `CopyProjectVersion` richiede l'accesso al bucket Amazon S3.
Il modello copiato include i risultati dell’addestramento per il modello sorgente, ma non include i set di dati di origine.
L' AWS account di origine non ha alcuna proprietà sul modello copiato in un account di destinazione, a meno che non si configurino le autorizzazioni appropriate.
**Per copiare un modello (SDK)**
1. Se non l'hai ancora fatto, installa e configura il AWS CLI . AWS SDKs Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Collega una policy di progetto al progetto sorgente seguendo le istruzioni riportate in [Collegare una policy di progetto (SDK)](md-attach-project-policy.md).
1. Se stai copiando il modello su un altro AWS account, assicurati di avere un progetto nell' AWS account di destinazione.
1. Utilizza il codice seguente per copiare la versione del modello in un progetto di destinazione.
------
#### [ AWS CLI ]
Imposta i valori seguenti:
+ `source-project-arn` per l'ARN del progetto di origine che contiene la versione del modello da copiare.
+ `source-project-version-arn` per l'ARN della versione del modello che desideri copiare.
+ `destination-project-arn` per l'ARN del progetto di destinazione in cui desideri copiare il modello.
+ `version-name` per un nome della versione per il modello nel progetto di destinazione.
+ `bucket` per il bucket S3 in cui desideri copiare i risultati dell'addestramento per il modello di origine.
+ `folder` per la cartella in `bucket` cui desideri copiare i risultati dell'addestramento per il modello sorgente.
+ (Facoltativo) `kms-key-id` per l'ID chiave di AWS Key Management Service per il modello.
+ (Facoltativo) `key` per una chiave di tag a tua scelta.
+ (Facoltativo) `value` per un valore di tag a tua scelta.
```
aws rekognition copy-project-version \
--source-project-arn source-project-arn \
--source-project-version-arn source-project-version-arn \
--destination-project-arn destination-project-arn \
--version-name version-name \
--output-config '{"S3Bucket":"bucket","S3KeyPrefix":"folder"}' \
--kms-key-id arn:myKey \
--tags '{"key":"key"}' \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `source_project_arn`— l'ARN del progetto di origine nell' AWS account di origine che contiene la versione del modello che si desidera copiare.
+ `source_project_version-arn`— l'ARN della versione del modello nell' AWS account di origine che si desidera copiare.
+ `destination_project_arn` — l'ARN del progetto di destinazione in cui desideri copiare il modello.
+ `destination_version_name` — un nome di versione per il modello nel progetto di destinazione.
+ `training_results` — la posizione S3 in cui si desidera copiare i risultati dell’addestramento per la versione del modello di origine.
+ (Facoltativo) `kms_key_id` per l'ID chiave di AWS Key Management Service per il modello.
+ (Facoltativo) `tag_name` per una chiave di tag a tua scelta.
+ (Facoltativo) `tag_value` per un valore di tag a tua scelta.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def copy_model(
rekognition_client, source_project_arn, source_project_version_arn,
destination_project_arn, training_results, destination_version_name):
"""
Copies a version of a Amazon Rekognition Custom Labels model.
:param rekognition_client: A Boto3 Amazon Rekognition Custom Labels client.
:param source_project_arn: The ARN of the source project that contains the
model that you want to copy.
:param source_project_version_arn: The ARN of the model version that you want
to copy.
:param destination_project_Arn: The ARN of the project that you want to copy the model
to.
:param training_results: The Amazon S3 location where training results for the model
should be stored.
return: The model status and version.
"""
try:
logger.info("Copying model...%s from %s to %s ", source_project_version_arn,
source_project_arn,
destination_project_arn)
output_bucket, output_folder = training_results.replace(
"s3://", "").split("/", 1)
output_config = {"S3Bucket": output_bucket,
"S3KeyPrefix": output_folder}
response = rekognition_client.copy_project_version(
DestinationProjectArn=destination_project_arn,
OutputConfig=output_config,
SourceProjectArn=source_project_arn,
SourceProjectVersionArn=source_project_version_arn,
VersionName=destination_version_name
)
destination_model_arn = response["ProjectVersionArn"]
logger.info("Destination model ARN: %s", destination_model_arn)
# Wait until training completes.
finished = False
status = "UNKNOWN"
while finished is False:
model_description = rekognition_client.describe_project_versions(ProjectArn=destination_project_arn,
VersionNames=[destination_version_name])
status = model_description["ProjectVersionDescriptions"][0]["Status"]
if status == "COPYING_IN_PROGRESS":
logger.info("Model copying in progress...")
time.sleep(60)
continue
if status == "COPYING_COMPLETED":
logger.info("Model was successfully copied.")
if status == "COPYING_FAILED":
logger.info(
"Model copy failed: %s ",
model_description["ProjectVersionDescriptions"][0]["StatusMessage"])
finished = True
except ClientError:
logger.exception("Couldn't copy model.")
raise
else:
return destination_model_arn, status
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"source_project_arn",
help="The ARN of the project that contains the model that you want to copy."
)
parser.add_argument(
"source_project_version_arn",
help="The ARN of the model version that you want to copy."
)
parser.add_argument(
"destination_project_arn",
help="The ARN of the project which receives the copied model."
)
parser.add_argument(
"destination_version_name",
help="The version name for the model in the destination project."
)
parser.add_argument(
"training_results",
help="The S3 location in the destination account that receives the training results for the copied model."
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# get command line arguments
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
print(
f"Copying model version {args.source_project_version_arn} to project {args.destination_project_arn}")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Copy the model.
model_arn, status = copy_model(rekognition_client,
args.source_project_arn,
args.source_project_version_arn,
args.destination_project_arn,
args.training_results,
args.destination_version_name,
)
print(f"Finished copying model: {model_arn}")
print(f"Status: {status}")
except ClientError as err:
print(f"Problem copying model: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `source_project_arn`— l'ARN del progetto di origine nell' AWS account di origine che contiene la versione del modello che si desidera copiare.
+ `source_project_version-arn`— l'ARN della versione del modello nell' AWS account di origine che si desidera copiare.
+ `destination_project_arn` — l'ARN del progetto di destinazione in cui desideri copiare il modello.
+ `destination_version_name` — un nome di versione per il modello nel progetto di destinazione.
+ `output_bucket` — il bucket S3 in cui desideri copiare i risultati dell’addestramento per la versione del modello di origine.
+ `output_folder` — la cartella di S3 in cui desideri copiare i risultati dell'addestramento per la versione del modello sorgente.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CopyProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.CopyProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CopyModel {
public static final Logger logger = Logger.getLogger(CopyModel.class.getName());
public static ProjectVersionDescription copyMyModel(RekognitionClient rekClient,
String sourceProjectArn,
String sourceProjectVersionArn,
String destinationProjectArn,
String versionName,
String outputBucket,
String outputFolder) throws InterruptedException {
try {
OutputConfig outputConfig = OutputConfig.builder().s3Bucket(outputBucket).s3KeyPrefix(outputFolder).build();
String[] logArguments = new String[] { versionName, sourceProjectArn, destinationProjectArn };
logger.log(Level.INFO, "Copying model {0} for from project {1} to project {2}", logArguments);
CopyProjectVersionRequest copyProjectVersionRequest = CopyProjectVersionRequest.builder()
.sourceProjectArn(sourceProjectArn)
.sourceProjectVersionArn(sourceProjectVersionArn)
.versionName(versionName)
.destinationProjectArn(destinationProjectArn)
.outputConfig(outputConfig)
.build();
CopyProjectVersionResponse response = rekClient.copyProjectVersion(copyProjectVersionRequest);
logger.log(Level.INFO, "Destination model ARN: {0}", response.projectVersionArn());
logger.log(Level.INFO, "Copying model...");
// wait until copying completes.
boolean finished = false;
ProjectVersionDescription copiedModel = null;
while (Boolean.FALSE.equals(finished)) {
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.versionNames(versionName)
.projectArn(destinationProjectArn)
.build();
DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
.describeProjectVersions(describeProjectVersionsRequest);
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
copiedModel = projectVersionDescription;
switch (projectVersionDescription.status()) {
case COPYING_IN_PROGRESS:
logger.log(Level.INFO, "Copying model...");
Thread.sleep(5000);
continue;
case COPYING_COMPLETED:
finished = true;
logger.log(Level.INFO, "Copying completed");
break;
case COPYING_FAILED:
finished = true;
logger.log(Level.INFO, "Copying failed...");
break;
default:
finished = true;
logger.log(Level.INFO, "Unexpected copy status %s",
projectVersionDescription.statusAsString());
break;
}
}
}
logger.log(Level.INFO, "Finished copying model {0} for from project {1} to project {2}", logArguments);
return copiedModel;
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not train model: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String sourceProjectArn = null;
String sourceProjectVersionArn = null;
String destinationProjectArn = null;
String versionName = null;
String bucket = null;
String location = null;
final String USAGE = "\n" + "Usage: "
+ " \n\n"
+ "Where:\n"
+ " source_project_arn - The ARN of the project that contains the model that you want to copy. \n\n"
+ " source_project_version_arn - The ARN of the project that contains the model that you want to copy. \n\n"
+ " destination_project_arn - The ARN of the destination project that you want to copy the model to. \n\n"
+ " version_name - A version name for the copied model.\n\n"
+ " output_bucket - The S3 bucket in which to place the training output. \n\n"
+ " output_folder - The folder within the bucket that the training output is stored in. \n\n";
if (args.length != 6) {
System.out.println(USAGE);
System.exit(1);
}
sourceProjectArn = args[0];
sourceProjectVersionArn = args[1];
destinationProjectArn = args[2];
versionName = args[3];
bucket = args[4];
location = args[5];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Copy the model.
ProjectVersionDescription copiedModel = copyMyModel(rekClient,
sourceProjectArn,
sourceProjectVersionArn,
destinationProjectArn,
versionName,
bucket,
location);
System.out.println(String.format("Model copied: %s Status: %s",
copiedModel.projectVersionArn(),
copiedModel.statusMessage()));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (InterruptedException intError) {
logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------
# Elenco delle policy del progetto (SDK)
Puoi utilizzare l'[ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)operazione per elencare le politiche di progetto allegate a un progetto Amazon Rekognition Custom Labels.
**Per elencare le policy di progetto collegate a un progetto (SDK)**
1. Se non l'hai ancora fatto, installa e configura il AWS CLI . AWS SDKs Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Usa il codice seguente per elencare le policy del progetto.
------
#### [ AWS CLI ]
Modifica `project-arn` con il nome Amazon Resource del progetto per il quale desideri elencare le policy di progetto collegate.
```
aws rekognition list-project-policies \
--project-arn project-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ project\$1arn — il nome della risorsa Amazon del progetto per il quale desideri elencare le policy di progetto collegate.
Ad esempio: `python list_project_policies.py project_arn `
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Amazon Rekognition Custom Labels model example used in the service documentation:
https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-copy-model-sdk.html
Shows how to list the project policies in an Amazon Rekogntion Custom Labels project.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def display_project_policy(project_policy):
"""
Displays information about a Custom Labels project policy.
:param project_policy: The project policy (ProjectPolicy)
that you want to display information about.
"""
print(f"Policy name: {(project_policy['PolicyName'])}")
print(f"Project Arn: {project_policy['ProjectArn']}")
print(f"Document: {(project_policy['PolicyDocument'])}")
print(f"Revision ID: {(project_policy['PolicyRevisionId'])}")
print()
def list_project_policies(rek_client, project_arn):
"""
Describes an Amazon Rekognition Custom Labels project, or all projects.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The Amazon Resource Name of the project you want to use.
"""
try:
max_results = 5
pagination_token = ''
finished = False
logger.info("Listing project policies in: %s.", project_arn)
print('Projects\n--------')
while not finished:
response = rek_client.list_project_policies(
ProjectArn=project_arn, MaxResults=max_results, NextToken=pagination_token)
for project in response['ProjectPolicies']:
display_project_policy(project)
if 'NextToken' in response:
pagination_token = response['NextToken']
else:
finished = True
logger.info("Finished listing project policies.")
except ClientError as err:
logger.exception(
"Couldn't list policies for - %s: %s",
project_arn,err.response['Error']['Message'])
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The Amazon Resource Name of the project for which you want to list project policies."
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# get command line arguments
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
print(f"Listing project policies in: {args.project_arn}")
# List the project policies.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
list_project_policies(rekognition_client,
args.project_arn)
except ClientError as err:
print(f"Problem list project_policies: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ project\$1arn — L'ARN del progetto che contiene le policy di progetto che desideri elencare.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import java.util.logging.Level;
import java.util.logging.Logger;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.ListProjectPoliciesRequest;
import software.amazon.awssdk.services.rekognition.model.ListProjectPoliciesResponse;
import software.amazon.awssdk.services.rekognition.model.ProjectPolicy;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class ListProjectPolicies {
public static final Logger logger = Logger.getLogger(ListProjectPolicies.class.getName());
public static void listMyProjectPolicies(RekognitionClient rekClient, String projectArn) {
try {
logger.log(Level.INFO, "Listing project policies for project: {0}", projectArn);
// List the project policies.
Boolean finished = false;
String nextToken = null;
while (Boolean.FALSE.equals(finished)) {
ListProjectPoliciesRequest listProjectPoliciesRequest = ListProjectPoliciesRequest.builder()
.maxResults(5)
.projectArn(projectArn)
.nextToken(nextToken)
.build();
ListProjectPoliciesResponse response = rekClient.listProjectPolicies(listProjectPoliciesRequest);
for (ProjectPolicy projectPolicy : response.projectPolicies()) {
System.out.println(String.format("Name: %s", projectPolicy.policyName()));
System.out.println(String.format("Revision ID: %s\n", projectPolicy.policyRevisionId()));
}
nextToken = response.nextToken();
if (nextToken == null) {
finished = true;
}
}
logger.log(Level.INFO, "Finished listing project policies for project: {0}", projectArn);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project with the project policies that you want to list.\n\n";
;
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String projectArn = args[0];
try {
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// List the project policies.
listMyProjectPolicies(rekClient, projectArn);
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Eliminazione di una policy di progetto (SDK)
Puoi utilizzare l'[DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy)operazione per eliminare una revisione di una politica di progetto esistente da un progetto Amazon Rekognition Custom Labels. Se desideri eliminare tutte le revisioni di una politica di progetto allegate a un progetto, utilizza questa opzione per [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)allegare la revisione IDs di ogni politica di progetto al progetto. Quindi chiama `DeletePolicy` per ogni nome di policy.
**Per eliminare una revisione di una policy di progetto (SDK)**
1. Se non l'hai ancora fatto, installa e configura il AWS CLI . AWS SDKs Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Utilizza il codice seguente per eliminare una policy di progetto.
DeletePolicy prende `ProjectARN` `PolicyName` e`PolicyRevisionId`. `ProjectARN`e `PolicyName` sono necessari per questa API. `PolicyRevisionId`è facoltativo, ma può essere incluso ai fini degli aggiornamenti atomici.
------
#### [ AWS CLI ]
Imposta i valori seguenti:
+ `policy-name` per il nome della policy di progetto che desideri eliminare.
+ `policy-revision-id` per l'ID di revisione della policy di progetto che desideri eliminare.
+ `project-arn` per l'Amazon Resource Name del progetto che contiene la revisione della policy del progetto che desideri eliminare.
```
aws rekognition delete-project-policy \
--policy-name policy-name \
--policy-revision-id policy-revision-id \
--project-arn project-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `policy-name` — Il nome della policy di progetto che desideri eliminare.
+ `project-arn` — Il nome della risorsa Amazon del progetto che contiene la policy del progetto che desideri eliminare.
+ `policy-revision-id` — L'ID di revisione della policy di progetto che desideri eliminare.
Ad esempio: `python delete_project_policy.py policy_name project_arn` *policy\$1revision\$1id*
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Amazon Rekognition Custom Labels model example used in the service documentation:
https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-copy-model-sdk.html
Shows how to delete a revision of a project policy.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def delete_project_policy(rekognition_client, policy_name, project_arn, policy_revision_id=None):
"""
Deletes a project policy.
:param rekognition_client: A Boto3 Amazon Rekognition client.
:param policy_name: The name of the project policy that you want to delete.
:param policy_revision_id: The revsion ID for the project policy that you want to delete.
:param project_arn: The Amazon Resource Name of the project that contains the project policy
that you want to delete.
"""
try:
logger.info("Deleting project policy: %s", policy_name)
if policy_revision_id is None:
rekognition_client.delete_project_policy(
PolicyName=policy_name,
ProjectArn=project_arn)
else:
rekognition_client.delete_project_policy(
PolicyName=policy_name,
PolicyRevisionId=policy_revision_id,
ProjectArn=project_arn)
logger.info("Deleted project policy: %s", policy_name)
except ClientError:
logger.exception("Couldn't delete project policy.")
raise
def confirm_project_policy_deletion(policy_name):
"""
Confirms deletion of the project policy. Returns True if delete entered.
:param model_arn: The ARN of the model that you want to delete.
"""
print(
f"Are you sure you wany to delete project policy {policy_name} ?\n", policy_name)
delete = input("Enter delete to delete your project policy: ")
if delete == "delete":
return True
else:
return False
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"policy_name", help="The ARN of the project that contains the project policy that you want to delete."
)
parser.add_argument(
"project_arn", help="The ARN of the project project policy you want to delete."
)
parser.add_argument(
"--policy_revision_id", help="(Optional) The revision ID of the project policy that you want to delete.",
required=False
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# Get command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
if confirm_project_policy_deletion(args.policy_name) is True:
print(f"Deleting project_policy: {args.policy_name}")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Delete the project policy.
delete_project_policy(rekognition_client,
args.policy_name,
args.project_arn,
args.policy_revision_id)
print(f"Finished deleting project policy: {args.policy_name}")
else:
print(f"Not deleting project policy {args.policy_name}")
except ClientError as err:
print(f"Couldn't delete project policy in {args.policy_name}: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `policy-name` — Il nome della policy di progetto che desideri eliminare.
+ `project-arn` — Il nome della risorsa Amazon del progetto che contiene la policy del progetto che desideri eliminare.
+ `policy-revision-id` — L'ID di revisione della policy di progetto che desideri eliminare.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import java.util.logging.Level;
import java.util.logging.Logger;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DeleteProjectPolicyRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class DeleteProjectPolicy {
public static final Logger logger = Logger.getLogger(DeleteProjectPolicy.class.getName());
public static void deleteMyProjectPolicy(RekognitionClient rekClient, String projectArn,
String projectPolicyName,
String projectPolicyRevisionId)
throws InterruptedException {
try {
String[] logArguments = new String[] { projectPolicyName, projectPolicyRevisionId };
logger.log(Level.INFO, "Deleting: Project policy: {0} revision: {1}", logArguments);
// Delete the project policy.
DeleteProjectPolicyRequest deleteProjectPolicyRequest = DeleteProjectPolicyRequest.builder()
.policyName(projectPolicyName)
.policyRevisionId(projectPolicyRevisionId)
.projectArn(projectArn).build();
rekClient.deleteProjectPolicy(deleteProjectPolicyRequest);
logger.log(Level.INFO, "Deleted: Project policy: {0} revision: {1}", logArguments);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: " + " \n\n"
+ "Where:\n"
+ " project_arn - The ARN of the project that has the project policy that you want to delete.\n\n"
+ " project_policy_name - The name of the project policy that you want to delete.\n\n"
+ " project_policy_revision_id - The revision of the project policy that you want to delete.\n\n";
if (args.length != 3) {
System.out.println(USAGE);
System.exit(1);
}
String projectArn = args[0];
String projectPolicyName = args[1];
String projectPolicyRevisionId = args[2];
try {
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Delete the project policy.
deleteMyProjectPolicy(rekClient, projectArn, projectPolicyName, projectPolicyRevisionId);
System.out.println(String.format("project policy deleted: %s revision: %s", projectPolicyName,
projectPolicyRevisionId));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
catch (InterruptedException intError) {
logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------