As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Como gerenciar um modelo do Amazon Rekognition Custom Labels
O modelo Amazon Rekognition Custom Labels é um modelo matemático que prevê a presença de objetos, cenas e conceitos em novas imagens. Ele faz isso descobrindo padrões nas imagens usadas para treinar o modelo. Esta seção mostra como treinar um modelo, avaliar seu desempenho e fazer melhorias. Também mostra como disponibilizar um modelo para uso e como excluir um modelo quando você não precisar mais dele.
**Topics**
+ [Como excluir um modelo do Amazon Rekognition Custom Labels](tm-delete-model.md)
+ [Como marcar um modelo](tm-tagging-model.md)
+ [Como descrever um modelo (SDK)](md-describing-model-sdk.md)
+ [Como copiar um modelo do Amazon Rekognition Custom Labels (SDK)](md-copy-model-overview.md)
# Como excluir um modelo do Amazon Rekognition Custom Labels
Você pode excluir um modelo usando o console Amazon Rekognition Custom Labels ou usando a API. [DeleteProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectVersion) Não é possível excluir um modelo se ele estiver em execução ou em treinamento. Para interromper a execução de um modelo, use a [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion)API. Para obter mais informações, consulte [Como interromper um modelo do Amazon Rekognition Custom Labels (SDK)](rm-stop.md#rm-stop-sdk). Se um modelo estiver sendo treinado, espere até que ele termine antes de excluí-lo.
Um modelo excluído não pode ser recuperado.
**Topics**
+ [Como excluir um modelo do Amazon Rekognition Custom Labels (console)](#tm-delete-model-console)
+ [Como excluir um modelo do Amazon Rekognition Custom Labels (SDK)](#tm-delete-model-sdk)
## Como excluir um modelo do Amazon Rekognition Custom Labels (console)
O procedimento a seguir mostra como excluir um modelo de uma página de detalhes do projeto. Também é possível excluir um modelo da página de detalhes de um modelo.
**Para excluir um canal (console)**
1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Escolha **Usar rótulos personalizados**.
1. Escolha **Comece a usar**.
1. No painel de navegação esquerdo, selecione **Projetos**.
1. Selecione o tópico que contém o modelo que você deseja excluir. A página de detalhes do projeto é aberta.
1. Na seção **Modelos**, escolha os modelos que deseja excluir.
**nota**
Se o modelo não puder ser selecionado, ele está em execução ou em treinamento e não pode ser excluído. Verifique o campo **Status** e tente novamente após interromper o modelo em execução ou espere até que o treinamento termine.
1. Escolha **Excluir modelo** e a **caixa de diálogo Excluir modelo será exibida**.
1. Insira **excluir** para confirmar a exclusão.
1. Escolha **Excluir** para excluir o modelo. A exclusão do modelo pode demorar um pouco para ser concluída.
**nota**
Se **Fechar** a caixa de diálogo durante a exclusão do modelo, os modelos ainda serão excluídos.
## Como excluir um modelo do Amazon Rekognition Custom Labels (SDK)
Você exclui um modelo de etiquetas personalizadas do Amazon Rekognition [DeleteProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectVersion)chamando e fornecendo o Amazon Resource Name (ARN) do modelo que você deseja excluir. É possível obter o ARN do modelo na seção **Use seu modelo** da página de detalhes do modelo no console do Amazon Rekognition Custom Labels. Como alternativa, ligue [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)e forneça o seguinte.
+ O ARN do projeto (`ProjectArn`) ao qual o trabalho está associado.
+ O nome da versão (`VersionNames`) do modelo.
O ARN do modelo é o `ProjectVersionArn` campo no [ProjectVersionDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectVersionDescription)objeto, a partir da `DescribeProjectVersions` resposta.
Não é possível excluir um modelo se ele estiver em execução ou em treinamento. Para determinar se o modelo está em execução ou em treinamento, ligue [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)e verifique o `Status` campo do [ProjectVersionDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectVersionDescription)objeto do modelo. Para interromper a execução de um modelo, use a [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion)API. Para obter mais informações, consulte [Como interromper um modelo do Amazon Rekognition Custom Labels (SDK)](rm-stop.md#rm-stop-sdk). É preciso esperar que um modelo termine o treinamento antes de excluí-lo.
**Para excluir um modelo (SDK)**
1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
1. Use o código a seguir para excluir um modelo.
------
#### [ AWS CLI ]
Altere o valor de `project-version-arn` para o nome do projeto que você deseja excluir.
```
aws rekognition delete-project-version --project-version-arn model_arn \
--profile custom-labels-access
```
------
#### [ Python ]
Forneça os seguintes parâmetros de linha de comando
+ `project_arn`: o ARN do projeto que contém o modelo que você deseja excluir.
+ `model_arn`: o ARN da versão do modelo que você deseja excluir.
```
# 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`: o ARN do projeto que contém o modelo que você deseja excluir.
+ `model_arn`: o ARN da versão do modelo que você deseja excluir.
```
//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);
}
}
}
```
------
# Como marcar um modelo
É possível identificar, organizar, pesquisar e filtrar seus modelos do Amazon Rekognition usando tags. Cada tag é um rótulo que consiste em um valor e uma chave definida pelo usuário. Por exemplo, para ajudar a determinar o faturamento de seus modelos, marque seus modelos com uma chave `Cost center` e adicione o número do centro de custo apropriado como valor. Para obter mais informações, consulte [Como rotular recursos da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Use tags para:
+ Acompanhe o faturamento de um modelo usando tags de alocação de custos. Para obter mais informações, consulte [Usar tags de alocação de custos](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html).
+ Controle o acesso a um modelo usando o AWS Identity and Access Management (IAM). Para obter mais informações, consulte [Controlar o acesso a recursos da AWS usando tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html).
+ Automatize o gerenciamento de modelos. Por exemplo, é possível executar scripts de inicialização ou interrupção automatizados que desativam modelos de desenvolvimento fora do horário comercial para reduzir os custos. Para obter mais informações, consulte [Como executar um modelo do Amazon Rekognition Custom Labels](running-model.md).
Você pode marcar modelos usando o console do Amazon Rekognition ou usando o. AWS SDKs
**Topics**
+ [Como marcar modelos (console)](#tm-tagging-model-console)
+ [Como visualizar tags de modelo](#tm-tagging-model-viewing-console)
+ [Como marcar modelos (SDK)](#tm-tagging-model-sdk)
## Como marcar modelos (console)
É possível usar o console do Rekognition para adicionar tags aos modelos, visualizar as tags anexadas a um modelo e remover tags.
### Adicionar e remover rótulos
Este procedimento explica como adicionar ou remover tags de um modelo existente. Também é possível adicionar tags a um modelo novo quando ele for treinado. Para obter mais informações, consulte [Como treinar um modelo do Amazon Rekognition Custom Labels](training-model.md).
**Para adicionar tags ou remover tags de um modelo existente usando o console**
1. Abra o console do Amazon Rekognition em. [ https://console.aws.amazon.com/rekognition/]( https://console.aws.amazon.com/rekognition/)
1. Escolha **Começar**.
1. No painel de navegação, selecione **Projetos**.
1. Na página de recursos **Projetos**, selecione o projeto que contém o modelo ao qual você deseja atribuir uma tag.
1. No painel de navegação, no projeto que você escolheu anteriormente, escolha **Modelos**.
1. Na seção **Modelos**, escolha o modelo ao qual deseja atribuir uma tag.
1. Na página de detalhes do modelo, escolha a guia **Tags**.
1. Na seção **Tags**, escolha **Gerenciar tags**.
1. Na página **Gerenciar tags**, escolha **Adicionar nova tag**.
1. Insira uma Chave e um Valor.
1. Em **Chave**, insira o nome da chave.
1. Em **Valor**, insira um valor.
1. Para adicionar mais tags, repita as etapas 9 e 10.
1. (Opcional) Para remover uma tag, selecione **Remover** ao lado da tag que você deseja remover. Se estiver removendo uma tag salva anteriormente, ela será removida quando você salvar suas alterações.
1. Escolha **Salvar alterações** para salvar suas alterações.
## Como visualizar tags de modelo
É possível usar o console do Amazon Rekognition para visualizar as tags anexadas a um modelo.
Para visualizar as tags anexadas a *todos os modelos em um projeto*, você deve usar o AWS SDK. Para obter mais informações, consulte [Como listar de tags de modelo](#listing-model-tags-sdk).
**Para visualizar as tags anexadas a um modelo**
1. Abra o console do Amazon Rekognition em. [ https://console.aws.amazon.com/rekognition/]( https://console.aws.amazon.com/rekognition/)
1. Escolha **Começar**.
1. No painel de navegação, selecione **Projetos**.
1. Na página de recursos **Projetos**, selecione o projeto que contém o modelo cuja tag você deseja visualizar.
1. No painel de navegação, no projeto que você escolheu anteriormente, escolha **Modelos**.
1. Na seção **Modelos**, escolha o modelo cujo rótulo você deseja exibir.
1. Na página de detalhes do modelo, escolha a guia **Tags**. As tags são mostradas na seção **Tags**.
## Como marcar modelos (SDK)
Você pode usar o AWS SDK para:
+ Adicionar tags a um novo modelo
+ Adicionar tags a um modelo existente
+ Liste as tags anexadas a um modelo
+ Remover tags de um modelo
As tags nos AWS CLI exemplos a seguir estão no formato a seguir.
```
--tags '{"key1":"value1","key2":"value2"}'
```
Como alternativa, é possível usar este formato.
```
--tags key1=value1,key2=value2
```
Se você não instalou o AWS CLI, consulte[Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
### Como adicionar tags a um novo modelo
Você pode adicionar tags a um modelo ao criá-lo usando a [CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion.html)operação. Especifique uma ou mais tags no parâmetro `Tags` de entrada da matriz.
```
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
```
Para obter informações sobre como criar e treinar um modelo, consulte [Treinando um modelo (SDK)](training-model.md#tm-sdk).
### Como adicionar tags a um modelo existente
Para adicionar uma ou mais tags a um modelo existente, use a [TagResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TagResource)operação. Especifique o nome do recurso da Amazon (ARN) (`ResourceArn`) do modelo e as tags (`Tags`) que deseja adicionar. O exemplo a seguir mostra como adicionar duas tags.
```
aws rekognition tag-resource --resource-arn resource-arn \
--tags '{"key1":"value1","key2":"value2"}' \
--profile custom-labels-access
```
Você pode obter o ARN de um modelo ligando para. [CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion)
### Como listar de tags de modelo
Para listar as tags anexadas a um modelo, use a [ListTagsForResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListTagsForResource)operação e especifique o ARN do modelo ()`ResourceArn`. A resposta é um mapa de tags e valores anexados ao modelo especificado.
```
aws rekognition list-tags-for-resource --resource-arn resource-arn \
--profile custom-labels-access
```
A saída exibe uma lista das tags anexadas ao modelo.
```
{
"Tags": {
"Dept": "Engineering",
"Name": "Ana Silva Carolina",
"Role": "Developer"
}
}
```
Para ver quais modelos em um projeto têm uma tag específica, chame `DescribeProjectVersions` para obter uma lista de modelos. Depois, chame `ListTagsForResource` para cada modelo na resposta de `DescribeProjectVersions`. Inspecione a resposta de `ListTagsForResource` para ver se a tag necessária está presente.
O exemplo a seguir do Python 3 mostra como pesquisar em todos os seus projetos uma chave e um valor de tag específicos. A saída inclui o ARN do projeto e o ARN do modelo em que uma chave correspondente é encontrada.
**Para pesquisar um valor de tag**
1. Salve o código a seguir em um arquivo chamado `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. No prompt de comando, digite o seguinte. *value*Substitua *key* e pelo nome e valor da chave que você deseja encontrar.
```
python find_tag.py key value
```
### Como excluir as tags de um modelo
Para remover uma ou mais tags de um modelo, use a [UntagResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UntagResource)operação. Especifique o ARN do modelo (`ResourceArn`) e as chaves de tag (`Tag-Keys`) que deseja remover.
```
aws rekognition untag-resource --resource-arn resource-arn \
--tag-keys '["key1","key2"]' \
--profile custom-labels-access
```
Como alternativa, é possível especificar `tag-keys` neste formato.
```
--tag-keys key1,key2
```
# Como descrever um modelo (SDK)
É possível usar a API `DescribeProjectVersions` para obter informações sobre uma versão de um modelo. Se não especificar `VersionName`, `DescribeProjectVersions` retornará as descrições de todas as versões do modelo no projeto.
**Para descrever um modelo (SDK)**
1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
1. Use o código de exemplo a seguir para descrever uma versão de um modelo.
------
#### [ AWS CLI ]
Altere o valor de `project-arn` para o ARN do projeto que você deseja descrever. Altere o valor de `version-name` para a versão do modelo que você deseja descrever.
```
aws rekognition describe-project-versions --project-arn project_arn \
--version-names version_name \
--profile custom-labels-access
```
------
#### [ Python ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ project\$1arn: o ARN do projeto que deseja descrever.
+ model\$1version: a versão do modelo que deseja descrever.
Por exemplo: `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 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ project\$1arn: o ARN do projeto que deseja descrever.
+ model\$1version: a versão do modelo que deseja descrever.
```
/*
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);
}
}
}
```
------
# Como copiar um modelo do Amazon Rekognition Custom Labels (SDK)
Você pode usar a [CopyProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CopyProjectVersion)operação para copiar uma versão do modelo Amazon Rekognition Custom Labels de um projeto de origem do Amazon Rekognition Custom Labels para um projeto de destino. O projeto de destino pode estar em uma AWS conta diferente ou na mesma AWS conta. Um cenário típico é copiar um modelo testado de uma AWS conta de desenvolvimento para uma AWS conta de produção.
Como alternativa, é possível treinar o modelo na conta de destino com o conjunto de dados de origem. Usar a operação `CopyProjectVersion` tem as seguintes vantagens:
+ O comportamento do modelo é consistente. O treinamento de modelos não é determinístico e não é garantido que dois modelos treinados com o mesmo conjunto de dados façam as mesmas previsões. Copiar o modelo com `CopyProjectVersion` ajuda a garantir que o comportamento do modelo copiado seja consistente com o modelo de origem e que você não precise testá-lo novamente.
+ O treinamento de modelos não é necessário. Isto economiza dinheiro, pois você é cobrado por cada treinamento bem-sucedido de um modelo.
Para copiar um modelo para uma AWS conta diferente, você deve ter um projeto Amazon Rekognition Custom Labels na conta de destino. AWS Para obter informações sobre como criar um projeto, consulte [Como criar um projeto](mp-create-project.md). Certifique-se de criar o projeto na AWS conta de destino.
Uma [política de projetos](md-create-project-policy-document.md) é uma política baseada em recursos que define permissões de cópia para a versão do modelo que você deseja copiar. Você precisará usar uma [política de projeto](md-create-project-policy-document.md) quando o projeto de destino estiver em uma AWS conta diferente do projeto de origem.
Não é preciso usar uma [política de projeto](md-create-project-policy-document.md) ao copiar versões do modelo na mesma conta. No entanto, é possível optar por uma [política de projetos](md-create-project-policy-document.md) em projetos entre contas se quiser ter mais controle sobre esses recursos.
Você anexa a política do projeto ao projeto de origem chamando a [PutProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PutProjectPolicy)operação.
Você não pode usar `CopyProjectVersion` para copiar um modelo para um projeto em uma AWS região diferente. Além disso, você não pode copiar um modelo com o console do Amazon Rekognition Custom Labels. Nestes casos, é possível treinar o modelo no projeto de destino com os conjuntos de dados usados para treinar o modelo de origem. Para obter mais informações, consulte [Como treinar um modelo do Amazon Rekognition Custom Labels](training-model.md).
Para copiar um modelo de um projeto de origem para um projeto de destino, faça o seguinte:
**Para copiar um modelo**
1. [Crie um documento de política do projeto](md-create-project-policy-document.md).
1. [Anexe a política de projeto ao projeto de origem](md-attach-project-policy.md).
1. [Copie o modelo com a operação `CopyProjectVersion`](md-copy-model-sdk.md).
Para remover uma política de projeto de um projeto, chame [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy). Para obter uma lista das políticas do projeto anexadas a um projeto, ligue [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
**Topics**
+ [Como criar um documento de política do projeto](md-create-project-policy-document.md)
+ [Como anexar uma política de projeto (SDK)](md-attach-project-policy.md)
+ [Como copiar um modelo (SDK)](md-copy-model-sdk.md)
+ [Como listar políticas do projeto (SDK)](md-list-project-policies.md)
+ [Como excluir uma política de projeto (SDK)](md-delete-project-policy.title.md)
# Como criar um documento de política do projeto
O Rekognition Custom Labels usa uma política baseada em recursos, conhecida como *política de projeto*, para gerenciar permissões de cópia para uma versão modelo. Uma política de projeto é um documento no formato JSON.
Uma política de projeto permite ou nega a permissão de uma [entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html#intro-structure-principal) para copiar uma versão do modelo de um projeto de origem para um projeto de destino. Você precisará de uma política de projeto se o projeto de destino estiver em uma AWS conta diferente. Isso também vale se o projeto de destino estiver na mesma conta da AWS do projeto de origem e você quiser restringir o acesso a versões específicas do modelo. Por exemplo, talvez você queira negar permissões de cópia para uma função específica do IAM em uma AWS conta.
O exemplo a seguir permite que a entidade principal `arn:aws:iam::111111111111:role/Admin` copie a versão do modelo `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` são campos obrigatórios em um documento de política de projetos.
A única `action` compatível é `rekognition:CopyProjectVersion`.
`NotAction`, `NotResource` e `NotPrincipal` são campos proibidos e não devem estar presentes no documento de política de projetos.
Se você não especificar uma política de projeto, um diretor na mesma AWS conta do projeto de origem ainda poderá copiar um modelo, se o diretor tiver uma política baseada em identidade, como, por exemplo` AmazonRekognitionCustomLabelsFullAccess`, que dê permissão para ligar. `CopyProjectVersion`
O procedimento a seguir cria um arquivo de documento de política de projeto que pode ser usado com o exemplo em Python em [Como anexar uma política de projeto (SDK)](md-attach-project-policy.md). Se você estiver usando o `put-project-policy` AWS CLI comando, forneça a política do projeto como uma string JSON.
**Para criar um documento de política do projeto**
1. Em um editor de texto, crie o documento a seguir. Altere os seguintes valores:
+ Efeito: especifique `ALLOW` para conceder permissão de cópia. Especifique `DENY` para negar a permissão de cópia.
+ Entidade principal: a entidade principal que deseja permitir ou negar o acesso às versões do modelo que você especificar em `Resource`. Por exemplo, você pode especificar o [principal da conta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#principal-accounts) para uma AWS conta diferente. Não restringimos as entidades principais que podem ser usados. Para obter mais informações, consulte [Especificar uma entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#Principal_specifying).
+ Recurso: o nome do recurso da Amazon (ARN) da versão do modelo para a qual você deseja especificar permissões de cópia. Se quiser conceder permissões para todas as versões do modelo dentro do projeto de origem, use o seguinte formato: `arn:aws:rekognition:region:account:project/source project/version/* `
1. Salve a política do projeto no seu computador.
1. Anexe a política de projeto ao projeto de origem seguindo as instruções em [Como anexar uma política de projeto (SDK)](md-attach-project-policy.md).
# Como anexar uma política de projeto (SDK)
Você anexa uma política de projeto a um projeto Amazon Rekognition Custom Labels chamando a operação. [PutProjectpolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PutProjectPolicy)
Anexe várias políticas de projeto a um projeto chamando `PutProjectPolicy` para cada política de projeto que você deseja adicionar. É possível anexar até cinco políticas de projeto a um projeto. Se precisar anexar mais políticas de projeto, solicite um aumento de [limite](limits.md).
Ao anexar pela primeira vez uma política de projeto exclusiva a um projeto, não especifique uma ID de revisão no parâmetro de entrada `PolicyRevisionId`. A resposta de `PutProjectPolicy` é um ID de revisão da política do projeto que o Amazon Rekognition Custom Labels cria para você. É possível usar o ID da revisão para atualizar ou excluir a revisão mais recente de uma política do projeto. O Amazon Rekognition Custom Labels mantém somente a revisão mais recente da política de um projeto. Se tentar atualizar ou excluir uma revisão anterior de uma política de projeto, receberá um erro `InvalidPolicyRevisionIdException`.
Para atualizar uma política de projeto existente, especifique o ID de revisão da política de projeto no parâmetro de entrada `PolicyRevisionId`. Você pode obter a revisão das IDs políticas do projeto em um projeto ligando para [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
Depois de anexar uma política de projeto a um projeto de origem, é possível copiar o modelo do projeto de origem para o projeto de destino. Para obter mais informações, consulte [Como copiar um modelo (SDK)](md-copy-model-sdk.md).
Para remover uma política de projeto de um projeto, chame [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy). Para obter uma lista das políticas do projeto anexadas a um projeto, ligue [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
**Para anexar uma política de projeto a um projeto (SDK)**
1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
1. [Crie um documento de política do projeto](md-create-project-policy-document.md).
1. Use o código a seguir para anexar a política do projeto ao projeto, na AWS conta confiável, que contém a versão do modelo que você deseja copiar. Para obter o ARN do projeto, ligue. [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-describing-project-sdk.html) Para obter a versão do modelo ARN, ligue. [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-describing-model-sdk.html)
------
#### [ AWS CLI ]
Altere os seguintes valores:
+ `project-arn`para o ARN do projeto de origem na AWS conta confiável que contém a versão do modelo que você deseja copiar.
+ `policy-name` para um nome de política que você escolher.
+ `principal` Para a entidade principal que deseja permitir ou negar o acesso às versões do modelo que você especificar no `Model version ARN`.
+ `project-version-arn` para o ARN da versão do modelo que você deseja copiar.
Se quiser atualizar uma política de projeto existente, especifique o parâmetro `policy-revision-id` e forneça o ID de revisão da política de projeto desejada.
```
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 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ `project_arn`: o ARN do projeto de origem ao qual você deseja anexar a política do projeto.
+ `policy_name`: um nome de política que você escolher.
+ `project_policy`: o arquivo que contém o documento de política do projeto.
+ `policy_revision_id`: (optional). Se quiser atualizar uma revisão existente da política de um projeto, especifique o ID de revisão da política de projeto.
```
# 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 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ `project_arn`: o ARN do projeto de origem ao qual você deseja anexar a política do projeto.
+ `project_policy_name`: um nome de política que você escolher.
+ `project_policy_document`: o arquivo que contém o documento de política do projeto.
+ `project_policy_revision_id`: (optional). Se quiser atualizar uma revisão existente da política de um projeto, especifique o ID de revisão da política de projeto.
```
/*
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. Copie a versão do modelo seguindo as instruções em [Como copiar um modelo (SDK)](md-copy-model-sdk.md).
# Como copiar um modelo (SDK)
É possível usar a API `CopyProjectVersion` para copiar uma versão do modelo de um projeto de origem para um projeto de destino. O projeto de destino pode estar em uma AWS conta diferente, mas deve estar na mesma AWS região. Se o projeto de destino estiver em uma AWS conta diferente (ou se você quiser conceder permissões específicas para uma versão do modelo copiada em uma AWS conta), você deverá anexar uma política de projeto ao projeto de origem. Para obter mais informações, consulte [Como criar um documento de política do projeto](md-create-project-policy-document.md). A API `CopyProjectVersion` requer acesso ao bucket do Amazon S3.
O modelo copiado inclui os resultados do treinamento para o modelo de origem, mas não inclui os conjuntos de dados de origem.
A AWS conta de origem não tem propriedade sobre o modelo copiado em uma conta de destino, a menos que você configure as permissões apropriadas.
**Para copiar um modelo (SDK)**
1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
1. Anexe uma política de projeto ao projeto de origem seguindo as instruções em [Como anexar uma política de projeto (SDK)](md-attach-project-policy.md).
1. Se você estiver copiando o modelo para uma AWS conta diferente, verifique se você tem um projeto na AWS conta de destino.
1. Use o código a seguir para copiar a versão do modelo para um projeto de destino.
------
#### [ AWS CLI ]
Altere os seguintes valores:
+ `source-project-arn` para o ARN do projeto de origem que contém a versão do modelo que você deseja copiar.
+ `source-project-version-arn` para o ARN da versão do modelo que você deseja copiar.
+ `destination-project-arn` para o ARN do projeto de destino no qual você deseja copiar o modelo.
+ `version-name` para um nome de versão do modelo no projeto de destino.
+ `bucket` para o bucket do S3 para o qual você deseja copiar os resultados do treinamento para o modelo de origem.
+ `folder` para a pasta no `bucket` para a qual você deseja copiar os resultados do treinamento para o modelo de origem.
+ (Opcional) `kms-key-id` para o ID da chave do AWS Key Management Service para o modelo.
+ (Opcional) `key` para uma chave de tag de sua escolha.
+ (Opcional) `value` para um valor de tag de sua escolha.
```
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 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ `source_project_arn`— o ARN do projeto de origem na AWS conta de origem que contém a versão do modelo que você deseja copiar.
+ `source_project_version-arn`— o ARN da versão do modelo na AWS conta de origem que você deseja copiar.
+ `destination_project_arn`: o ARN do projeto de destino para o qual você deseja copiar o modelo.
+ `destination_version_name`: um nome de versão para o modelo no projeto de destino.
+ `training_results`: a localização do S3 para o qual você deseja copiar os resultados do treinamento para o modelo de origem.
+ (Opcional) `kms_key_id` para o ID da chave do AWS Key Management Service para o modelo.
+ (Opcional) `tag_name` para uma chave de tag de sua escolha.
+ (Opcional) `tag_value` para um valor de tag de sua escolha.
```
# 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 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ `source_project_arn`— o ARN do projeto de origem na AWS conta de origem que contém a versão do modelo que você deseja copiar.
+ `source_project_version-arn`— o ARN da versão do modelo na AWS conta de origem que você deseja copiar.
+ `destination_project_arn`: o ARN do projeto de destino para o qual você deseja copiar o modelo.
+ `destination_version_name`: um nome de versão para o modelo no projeto de destino.
+ `output_bucket`: o bucket do S3 para o qual você deseja copiar os resultados do treinamento para o modelo de origem.
+ `output_folder`: a pasta no S3 para a qual você deseja copiar os resultados do treinamento para a versão do modelo de origem.
```
/*
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);
}
}
}
```
------
# Como listar políticas do projeto (SDK)
Você pode usar a [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)operação para listar as políticas do projeto que estão anexadas a um projeto Amazon Rekognition Custom Labels.
**Para listar as políticas de projeto a um projeto (SDK)**
1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
1. Use o código a seguir para listar as políticas do projeto.
------
#### [ AWS CLI ]
Altere `project-arn` para o nome do recurso da Amazon do projeto para o qual você deseja listar as políticas do projeto em anexo.
```
aws rekognition list-project-policies \
--project-arn project-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ project\$1arn: o nome do recurso da Amazon do projeto para o qual você deseja listar as políticas do projeto em anexo.
Por exemplo: `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 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ project\$1arn: o ARN do projeto que tem as políticas do projeto que você deseja listar.
```
/*
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);
}
}
}
```
------
# Como excluir uma política de projeto (SDK)
Você pode usar a [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy)operação para excluir uma revisão de uma política de projeto existente de um projeto Amazon Rekognition Custom Labels. Se você quiser excluir todas as revisões de uma política de projeto que estão anexadas a um projeto, use [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)para obter a revisão IDs de cada política de projeto anexada ao projeto. Em seguida, chame `DeletePolicy` para cada nome de política.
**Para excluir uma revisão de uma política de projeto (SDK)**
1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
1. Use o código a seguir para excluir uma política de projeto.
DeletePolicy leva`ProjectARN`, `PolicyName` `PolicyRevisionId` e. `ProjectARN`e `PolicyName` são necessários para essa API. `PolicyRevisionId`é opcional, mas pode ser incluído para fins de atualizações atômicas.
------
#### [ AWS CLI ]
Altere os seguintes valores:
+ `policy-name` para o nome da política de projetos que você deseja excluir.
+ `policy-revision-id` para o ID de revisão da política de projetos que você deseja excluir.
+ `project-arn` para o nome do recurso da Amazon do projeto que contém a revisão da política do projeto que você deseja excluir.
```
aws rekognition delete-project-policy \
--policy-name policy-name \
--policy-revision-id policy-revision-id \
--project-arn project-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ `policy-name`: o nome da política de projetos que você deseja excluir.
+ `project-arn`: o nome do recurso da Amazon do projeto que contém a revisão da política do projeto que você deseja excluir.
+ `policy-revision-id`: o ID de revisão da política de projetos que você deseja excluir.
Por exemplo: `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 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ `policy-name`: o nome da política de projetos que você deseja excluir.
+ `project-arn`: o nome do recurso da Amazon do projeto que contém a revisão da política do projeto que você deseja excluir.
+ `policy-revision-id`: o ID de revisão da política de projetos que você deseja excluir.
```
/*
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);
}
}
}
```
------