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 criar um projeto
<a name="mp-create-project"></a>

Um projeto gerencia as versões do modelo, o conjunto de dados de treinamento e o conjunto de dados de teste de um modelo. É possível criar um projeto com o console do Amazon Rekognition Custom Labels ou com a API. Para outras tarefas do projeto, como excluir um projeto, consulte [Como gerenciar um projeto do Amazon Rekognition Custom Labels](managing-project.md).

 Você pode usar etiquetas para categorizar e gerenciar os recursos do Amazon Rekognition Custom Labels, incluindo seus projetos. 

 A [CreateProject](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProject)operação permite que você opcionalmente especifique tags ao criar um novo projeto, fornecendo as tags como pares de valores-chave que você pode usar para categorizar e gerenciar seus recursos. 

## Como criar um projeto do Amazon Rekognition Custom Labels (console)
<a name="mp-create-project-console"></a>

É possível usar o console do Amazon Rekognition Custom Labels para criar um projeto. Na primeira vez que você usa o console em uma nova AWS região, o Amazon Rekognition Custom Labels solicita a criação de um bucket do Amazon S3 (bucket do console) em sua conta. AWS Esse bucket será usado para armazenar arquivos do projeto. Não é possível usar o console do Amazon Rekognition Custom Labels a menos que o bucket de console seja criado.

É possível usar o console do Amazon Rekognition Custom Labels para criar um projeto. 

**Para criar um projeto (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)

1. No painel esquerdo, escolha **Usar rótulos personalizados**. A página inicial do Amazon Rekognition Custom Labels é exibida.

1. Na página inicial do Amazon Rekognition Custom Labels, escolha **Conceitos básicos**.

1. No painel esquerdo, selecione **Projetos**. 

1. Escolha **Criar projeto**. 

1. Em **Nome do projeto**, digite um nome para o seu projeto. 

1. Escolha **Criar projeto** para criar seu projeto. 

1. Siga as etapas em [Como criar conjuntos de dados de treinamento e teste](creating-datasets.md) para criar os conjuntos de dados de treinamento e teste para seu projeto.

## Como criar um projeto do Amazon Rekognition Custom Labels (SDK)
<a name="mp-create-project-sdk"></a>

Você cria um projeto Amazon Rekognition Custom Labels ligando para. [CreateProject](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProject) A resposta é um nome do recurso da Amazon (ARN) que identifica o projeto. Depois de criar um projeto, você cria conjuntos de dados para treinar e testar um modelo. Para obter mais informações, consulte [Como criar conjuntos de dados de treinamento e teste com imagens](md-create-dataset.md). 

**Para criar 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 criar um projeto. 

------
#### [ AWS CLI ]

   O exemplo a seguir cria um projeto e exibe seu ARN.

   Altere o valor de `project-name` para o nome do projeto que você deseja criar.

   ```
   aws rekognition create-project --project-name my_project \
    --profile custom-labels-access --"CUSTOM_LABELS" --tags'{"key1":"value1","key2":"value2"}'
   ```

------
#### [ Python ]

   O exemplo a seguir cria um projeto e exibe seu ARN. Forneça os seguintes argumentos de linha de comando:
   + `project_name`: o nome do projeto que você deseja criar.

   ```
   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier: Apache-2.0
   
   import argparse
   import logging
   import boto3
   
   from botocore.exceptions import ClientError
   
   logger = logging.getLogger(__name__)
   
   def create_project(rek_client, project_name):
       """
       Creates an Amazon Rekognition Custom Labels project
       :param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
       :param project_name: A name for the new prooject.
       """
   
       try:
           #Create the project.
           logger.info("Creating project: %s",project_name)
           
           response=rek_client.create_project(ProjectName=project_name)
           
           logger.info("project ARN: %s",response['ProjectArn'])
   
           return response['ProjectArn']
      
       
       except ClientError as err:  
           logger.exception("Couldn't create project - %s: %s", project_name, 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_name", help="A name for the new project."
       )
   
   
   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"Creating project: {args.project_name}")
   
           # Create the project.
           session = boto3.Session(profile_name='custom-labels-access')
           rekognition_client = session.client("rekognition")
   
           project_arn=create_project(rekognition_client, 
               args.project_name)
   
           print(f"Finished creating project: {args.project_name}")
           print(f"ARN: {project_arn}")
   
       except ClientError as err:
           logger.exception("Problem creating project: %s", err)
           print(f"Problem creating project: {err}")
   
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ Java V2 ]

   O exemplo a seguir cria um projeto e exibe seu ARN.

   Forneça o seguinte argumento de linha de comando:
   + `project_name`: o nome do projeto que você deseja criar.

   ```
   /*
      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.CreateProjectRequest;
   import software.amazon.awssdk.services.rekognition.model.CreateProjectResponse;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   
   import java.util.logging.Level;
   import java.util.logging.Logger;
   
   public class CreateProject {
   
       public static final Logger logger = Logger.getLogger(CreateProject.class.getName());
   
       public static String createMyProject(RekognitionClient rekClient, String projectName) {
   
           try {
   
               logger.log(Level.INFO, "Creating project: {0}", projectName);
               CreateProjectRequest createProjectRequest = CreateProjectRequest.builder().projectName(projectName).build();
   
               CreateProjectResponse response = rekClient.createProject(createProjectRequest);
   
               logger.log(Level.INFO, "Project ARN: {0} ", response.projectArn());
   
               return response.projectArn();
   
           } catch (RekognitionException e) {
               logger.log(Level.SEVERE, "Could not create project: {0}", e.getMessage());
               throw e;
           }
   
       }
   
       public static void main(String[] args) {
   
           final String USAGE = "\n" + "Usage: " + "<project_name> <bucket> <image>\n\n" + "Where:\n"
                   + "   project_name - A name for the new project\n\n";
   
           if (args.length != 1) {
               System.out.println(USAGE);
               System.exit(1);
           }
   
           String projectName = args[0];
           String projectArn = null;
           ;
   
           try {
   
               // Get the Rekognition client.
               RekognitionClient rekClient = RekognitionClient.builder()
                   .credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
                   .region(Region.US_WEST_2)
                   .build();
   
               // Create the project
               projectArn = createMyProject(rekClient, projectName);
   
               System.out.println(String.format("Created project: %s %nProject ARN: %s", projectName, projectArn));
   
               rekClient.close();
   
           } catch (RekognitionException rekError) {
               logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
               System.exit(1);
           }
   
       }
   
   }
   ```

------

1. Observe o nome do ARN do projeto exibido na resposta. Será necessário para criar um modelo. 

1. Siga as etapas em [Crie conjuntos de dados de treinamento e teste (SDK)](md-create-dataset.md#cd-create-dataset-sdk) para criar os conjuntos de dados de treinamento e teste para seu projeto.

## CreateProject solicitação de operação
<a name="create-project-request"></a>

 Veja a seguir o formato da solicitação de CreateProject operação: 

```
{
 "AutoUpdate": "string",
 "Feature": "string", 
 "ProjectName": "string",
 "Tags": {
 "string": "string"
 }
}
```