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á. # Comece a usar o Amazon Managed Service para Apache Flink (DataStream API) Esta seção apresenta os conceitos fundamentais do Managed Service for Apache Flink e a implementação de um aplicativo em Java usando a API. DataStream Ela descreve as opções disponíveis para criar e testar seus aplicativos. Ela também fornece instruções para instalar as ferramentas necessárias para concluir os tutoriais deste guia e criar seu primeiro aplicativo. **Topics** + [ ## Analise os componentes do aplicativo do Managed Service for Apache Flink ](#getting-started-components) + [ ## Atenda os pré-requisitos para concluir os exercícios ](#setting-up-prerequisites) + [ # Configurar uma AWS conta e criar um usuário administrador ](setting-up.md) + [ # Configure o AWS Command Line Interface (AWS CLI) ](setup-awscli.md) + [ # Crie e execute um aplicativo Managed Service for Apache Flink ](get-started-exercise.md) + [ # Limpe AWS os recursos ](getting-started-cleanup.md) + [ # Explorar recursos adicionais ](getting-started-next-steps.md) ## Analise os componentes do aplicativo do Managed Service for Apache Flink **nota** O Amazon Managed Service para Apache Flink oferece suporte a todo o Apache Flink APIs e, potencialmente, a todas as linguagens da JVM. Para obter mais informações, consulte [Flink's APIs](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/concepts/overview/#flinks-apis). Dependendo da API selecionada, a estrutura do aplicativo e a implementação são um pouco diferentes. Este tutorial de introdução aborda a implementação dos aplicativos usando a DataStream API em Java. Para processar dados, seu aplicativo do Managed Service for Apache Flink usa um aplicativo Java que processa a entrada e produz a saída usando o runtime do Apache Flink. Um aplicativo típico do Managed Service for Apache Flink tem os seguintes componentes: + **Propriedades de runtime:** você pode usar *propriedades de runtime* para passar parâmetros de configuração para seu aplicativo e alterá-los sem modificar e republicar o código. + **Fontes:** o aplicativo consome dados de uma ou mais *fontes*. Uma fonte usa um [conector](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/connectors/table/overview/) para ler dados de um sistema externo, como um fluxo de dados do Kinesis ou um bucket do Kafka. Para obter mais informações, consulte [Adicione fontes de dados de transmissão](how-sources.md). + **Operadores:** o aplicativo processa dados usando um ou mais *operadores*. Um operador pode transformar, enriquecer ou agregar dados. Para obter mais informações, consulte [Operadores](how-operators.md). + **Coletores:** o aplicativo envia dados para fontes externas por meio de *coletores*. Um coletor usa um [conector](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/connectors/table/overview/) para enviar dados para um fluxo de dados do Kinesis, um tópico do Kafka, Amazon S3 ou um banco de dados relacional. Também é possível usar um conector especial para imprimir a saída somente para fins de desenvolvimento. Para obter mais informações, consulte [Grave dados usando coletores ](how-sinks.md). O aplicativo requer algumas *dependências externas*, como os conectores Flink que seu aplicativo usa ou, potencialmente, uma biblioteca Java. Para ser executado no Amazon Managed Service for Apache Flink, o aplicativo deve ser empacotado junto com as dependências em um arquivo *fat-jar* e carregado em um bucket do Amazon S3. Em seguida, crie um aplicativo do Managed Service for Apache Flink. Você passa a localização do pacote de código, junto com qualquer outro parâmetro de configuração de runtime. Este tutorial demonstra como usar o Apache Maven para empacotar o aplicativo e como executá-lo localmente no IDE de sua escolha. ## Atenda os pré-requisitos para concluir os exercícios Para concluir as etapas neste guia, é necessário ter o seguinte: + [Cliente do Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git). Instale o cliente do Git, se isso ainda não o fez. + [Kit de Desenvolvimento Java (JDK) versão 11](https://www.oracle.com/java/technologies/downloads/#java11). Instale o Java JDK 11 e defina a variável de ambiente `JAVA_HOME` para apontar o local da instalação do seu JDK. Se você não tiver um JDK 11, pode usar o [Amazon Coretto 11](https://docs.aws.amazon.com/corretto/latest/corretto-11-ug/what-is-corretto-11.html) ou qualquer outro JDK padrão de sua escolha. + Para verificar se o JDK está instalado corretamente, execute o seguinte comando. A saída será diferente se estiver usando um JDK diferente do Amazon Corretto. Verifique se a versão é a 11.x. ``` $ java --version openjdk 11.0.23 2024-04-16 LTS OpenJDK Runtime Environment Corretto-11.0.23.9.1 (build 11.0.23+9-LTS) OpenJDK 64-Bit Server VM Corretto-11.0.23.9.1 (build 11.0.23+9-LTS, mixed mode) ``` + [Apache Maven](https://maven.apache.org/). Instale o Apache Maven, caso ainda não tenha instalado. Para saber como instalar, consulte [Instalando o Apache Maven](https://maven.apache.org/install.html). + Para testar a instalação do Apache Maven, insira o seguinte: ``` $ mvn -version ``` + IDE para desenvolvimento local. Recomenda-se o uso de um ambiente de desenvolvimento como o [Eclipse Java Neon](https://www.eclipse.org/downloads/packages/release/neon/3) ou o [IntelliJ Idea](https://www.jetbrains.com/idea/) para desenvolver e compilar seu aplicativo. + Para testar a instalação do Apache Maven, insira o seguinte: ``` $ mvn -version ``` Para começar a usar, acesse [Configurar uma AWS conta e criar um usuário administrador](setting-up.md). # Configurar uma AWS conta e criar um usuário administrador Antes de usar o Managed Service for Apache Flink pela primeira vez, execute as seguintes tarefas: ## Inscreva-se para um Conta da AWS Se você não tiver um Conta da AWS, conclua as etapas a seguir para criar um. **Para se inscrever em um Conta da AWS** 1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup) 1. Siga as instruções online. Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone. Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks). AWS envia um e-mail de confirmação após a conclusão do processo de inscrição. A qualquer momento, você pode visualizar a atividade atual da sua conta e gerenciar sua conta acessando [https://aws.amazon.com/e](https://aws.amazon.com/) escolhendo **Minha conta**. ## Criar um usuário com acesso administrativo Depois de se inscrever em um Conta da AWS, proteja seu Usuário raiz da conta da AWS Centro de Identidade do AWS IAM, habilite e crie um usuário administrativo para que você não use o usuário root nas tarefas diárias. **Proteja seu Usuário raiz da conta da AWS** 1. Faça login [Console de gerenciamento da AWS](https://console.aws.amazon.com/)como proprietário da conta escolhendo **Usuário raiz** e inserindo seu endereço de Conta da AWS e-mail. Na próxima página, insira a senha. Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS *. 1. Habilite a autenticação multifator (MFA) para o usuário-raiz. Para obter instruções, consulte [Habilitar um dispositivo de MFA virtual para seu usuário Conta da AWS raiz (console) no Guia](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) do *usuário do IAM*. **Criar um usuário com acesso administrativo** 1. Habilita o Centro de Identidade do IAM. Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM *. 1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário. Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte [Configurar o acesso do usuário com o padrão Diretório do Centro de Identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia Centro de Identidade do AWS IAM do usuário*. **Iniciar sessão como o usuário com acesso administrativo** + Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado. Para obter ajuda para fazer login usando um usuário do IAM Identity Center, consulte Como [fazer login no portal de AWS acesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) no *Guia Início de Sessão da AWS do usuário*. **Atribuir acesso a usuários adicionais** 1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo. Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM *. 1. Atribua usuários a um grupo e, em seguida, atribua o acesso de logon único ao grupo. Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM *. ## Conceder acesso programático Os usuários precisam de acesso programático se quiserem interagir com pessoas AWS fora do Console de gerenciamento da AWS. A forma de conceder acesso programático depende do tipo de usuário que está acessando AWS. Para conceder acesso programático aos usuários, selecione uma das seguintes opções: **** | Qual usuário precisa de acesso programático? | Para | Por | | --- | --- | --- | | IAM | (Recomendado) Use as credenciais do console como credenciais temporárias para assinar solicitações programáticas para o AWS CLI, AWS SDKs ou. AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/managed-flink/latest/java/setting-up.html) | | Identidade da força de trabalho (Usuários gerenciados no Centro de Identidade do IAM) | Use credenciais temporárias para assinar solicitações programáticas para o AWS CLI AWS SDKs, ou. AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/managed-flink/latest/java/setting-up.html) | | IAM | Use credenciais temporárias para assinar solicitações programáticas para o AWS CLI AWS SDKs, ou. AWS APIs | Siga as instruções em [Como usar credenciais temporárias com AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) no Guia do usuário do IAM. | | IAM | (Não recomendado)Use credenciais de longo prazo para assinar solicitações programáticas para o AWS CLI AWS SDKs, ou. AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/managed-flink/latest/java/setting-up.html) | ## Próxima etapa [Configure o AWS Command Line Interface (AWS CLI)](setup-awscli.md) # Configure o AWS Command Line Interface (AWS CLI) Nesta etapa, você baixa e configura o AWS CLI para usar com o Managed Service para Apache Flink. **nota** Os exercícios de conceitos básicos neste guia pressupõem o uso de credenciais de administrador (`adminuser`) em sua conta para executar as operações. **nota** Se você já tem o AWS CLI instalado, talvez seja necessário fazer o upgrade para obter a funcionalidade mais recente. Para obter mais informações, consulte [Instalar a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) no *Guia do usuário da AWS Command Line Interface *. Para verificar a versão do AWS CLI, execute o seguinte comando: ``` aws --version ``` Os exercícios deste tutorial exigem a seguinte AWS CLI versão ou posterior: ``` aws-cli/1.16.63 ``` **Para configurar o AWS CLI** 1. Faça download e configure a AWS CLI. Para obter instruções, consulte os seguintes tópicos no *Guia do usuário do AWS Command Line Interface *: + [Instalar a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) + [Configurando a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) 1. Adicione um perfil nomeado para o usuário administrador no AWS CLI `config` arquivo. É possível usar esse perfil ao executar os comandos da AWS CLI . Para obter mais informações sobre perfis nomeados, consulte [Perfis nomeados](https://docs.aws.amazon.com/cli/latest/userguide/cli-multiple-profiles.html) no *Guia do usuário da AWS Command Line Interface *. ``` [profile adminuser] aws_access_key_id = adminuser access key ID aws_secret_access_key = adminuser secret access key region = aws-region ``` Para obter uma lista das AWS regiões disponíveis, consulte [Regiões e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html) no *Referência geral da Amazon Web Services*. **nota** O exemplo de código e comandos neste tutorial usam a região us-east-1 Leste dos EUA (Norte da Virgínia). Para usar uma região diferente, altere a região no código e nos comandos deste tutorial para a região que você deseja usar. 1. Verifique a configuração digitando o seguinte comando no prompt de comando: ``` aws help ``` Depois de configurar uma AWS conta e a AWS CLI, você pode tentar o próximo exercício, no qual você configura um aplicativo de amostra e testa a end-to-end configuração. ## Próxima etapa [Crie e execute um aplicativo Managed Service for Apache Flink](get-started-exercise.md) # Crie e execute um aplicativo Managed Service for Apache Flink Nesta etapa, será criado um aplicativo Managed Service for Apache Flink com fluxos de dados do Kinesis como fonte e coletor. **Topics** + [ ## Crie recursos dependentes ](#get-started-exercise-0) + [ ## Configurar seu ambiente de desenvolvimento local ](#get-started-exercise-2) + [ ## Baixar e examinar o código Java de fluxo do Apache Flink ](#get-started-exercise-5) + [ ## Gravação de registros de amostra no fluxo de entrada ](#get-started-exercise-5-4) + [ ## Execute o aplicativo localmente ](#get-started-exercise-5-run) + [ ## Observe os dados de entrada e saída nos fluxos do Kinesis ](#get-started-exercise-input-output) + [ ## Interrompa seu aplicativo em execução localmente ](#get-started-exercise-stop) + [ ## Compile e empacote o código do aplicativo ](#get-started-exercise-5-5) + [ ## Faça upload do arquivo JAR do código do aplicativo ](#get-started-exercise-6) + [ ## Crie e configure o aplicativo do Managed Service for Apache Flink ](#get-started-exercise-7) + [ ## Próxima etapa ](#get-started-exercise-next-step-4) ## Crie recursos dependentes Antes de criar um aplicativo Managed Service for Apache Flink para este exercício, você cria os seguintes recursos dependentes: + Dois fluxos de dados do Kinesis para entrada e saída. + Um bucket do Amazon S3 para armazenar o código do aplicativo **nota** Este tutorial pressupõe que você está implantando seu aplicativo na região us-east-1 Leste dos EUA (Norte da Virgínia). Se você usa outra região, adapte todas as etapas corretamente. ### Criar dois fluxos de dados do Amazon Kinesis Antes de criar um aplicativo do Managed Service for Apache Flink para este exercício, crie dois fluxos de dados do Kinesis (`ExampleInputStream` e `ExampleOutputStream`). O aplicativo usa esses fluxos para os fluxos de origem e de destino do aplicativo. Você pode criar esses streams usando o console do Amazon Kinesis ou o comando a AWS CLI seguir. Para obter instruções sobre o console, consulte [Criar e atualizar fluxos de dados](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html) no *Guia do desenvolvedor do Amazon Kinesis Data Streams*. Para criar os fluxos usando o AWS CLI, use os comandos a seguir, ajustando-se à região que você usa para seu aplicativo. **Como criar os fluxos de dados (AWS CLI)** 1. Para criar o primeiro stream (`ExampleInputStream`), use o seguinte comando do Amazon Kinesis `create-stream` AWS CLI : ``` $ aws kinesis create-stream \ --stream-name ExampleInputStream \ --shard-count 1 \ --region us-east-1 \ ``` 1. Para criar o segundo fluxo que o aplicativo usa para gravar a saída, execute o mesmo comando, alterando o nome do fluxo para`ExampleOutputStream`: ``` $ aws kinesis create-stream \ --stream-name ExampleOutputStream \ --shard-count 1 \ --region us-east-1 \ ``` ### Crie um bucket do Amazon S3 para o código do aplicativo Você pode criar um bucket do Amazon S3 usando o console. Para saber como criar um bucket do Amazon S3 usando o console, consulte [Criação de um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) no [Guia do usuário do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/). Dê ao bucket do Amazon S3 um nome globalmente exclusivo anexando seu nome de login, por exemplo. **nota** Crie o bucket na região que utilizada neste tutorial (us-east-1). ### Outros recursos da Quando você cria seu aplicativo, o Managed Service for Apache Flink cria automaticamente os seguintes CloudWatch recursos da Amazon, caso eles ainda não existam: + Um grupo de logs chamado `/AWS/KinesisAnalytics-java/` + Um fluxo de logs chamado `kinesis-analytics-log-stream` ## Configurar seu ambiente de desenvolvimento local Para desenvolvimento e depuração, você pode executar o aplicativo Apache Flink em sua máquina diretamente do IDE de sua escolha. Todas as dependências do Apache Flink são tratadas como dependências Java regulares usando o Apache Maven. **nota** Na máquina de desenvolvimento, você deve ter o Java JDK 11, o Maven e o Git instalados. Recomenda-se o uso de um ambiente de desenvolvimento como o [Eclipse Java Neon](https://www.eclipse.org/downloads/packages/release/neon/3) ou o [IntelliJ Idea](https://www.jetbrains.com/idea/). Para verificar se você atende a todos os pré-requisitos, consulte [Atenda os pré-requisitos para concluir os exercícios](getting-started.md#setting-up-prerequisites). Você **não** precisa instalar um cluster Apache Flink na máquina. ### Autentique sua sessão AWS O aplicativo usa fluxos de dados do Kinesis para publicar dados. Ao executar localmente, você deve ter uma sessão AWS autenticada válida com permissões para gravar no stream de dados do Kinesis. Use as etapas a seguir para autenticar sua sessão: 1. Se você não tiver o AWS CLI e um perfil nomeado com credencial válida configurado, consulte[Configure o AWS Command Line Interface (AWS CLI)](setup-awscli.md). 1. Verifique se o seu AWS CLI está configurado corretamente e se seus usuários têm permissões para gravar no stream de dados do Kinesis publicando o seguinte registro de teste: ``` $ aws kinesis put-record --stream-name ExampleOutputStream --data TEST --partition-key TEST ``` 1. Se o seu IDE tiver um plug-in com o qual se integrar AWS, você poderá usá-lo para passar as credenciais para o aplicativo em execução no IDE. Para obter mais informações, consulte [Toolkit do AWS para IntelliJ IDEA](https://aws.amazon.com/intellij/) e [Toolkit do AWS para Eclipse](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/welcome.html). ## Baixar e examinar o código Java de fluxo do Apache Flink O código do aplicativo Java para este exemplo está disponível em GitHub. Para fazer download do código do aplicativo, faça o seguinte: 1. Duplique o repositório remoto usando o seguinte comando: ``` git clone https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples.git ``` 1. Navegue até o diretório `amazon-managed-service-for-apache-flink-examples/tree/main/java/GettingStarted`. ### Analise os componentes do aplicativo O aplicativo é totalmente implementado na classe `com.amazonaws.services.msf.BasicStreamingJob`. O método `main()` define o fluxo de dados para processar os dados de transmissão e executá-los. **nota** Para uma experiência de desenvolvedor otimizada, o aplicativo foi projetado para ser executado sem nenhuma alteração de código no Amazon Managed Service for Apache Flink e localmente, para desenvolvimento em seu IDE. + Para ler a configuração de runtime para que ela funcione ao ser executada no Amazon Managed Service for Apache Flink e em seu IDE, o aplicativo detecta automaticamente se está sendo executado localmente de forma autônoma no IDE. Nesse caso, o aplicativo carrega a configuração do runtime de forma diferente: 1. Quando o aplicativo detectar que está sendo executado no modo autônomo em seu IDE, forme o arquivo `application_properties.json` incluído na pasta de **recursos** do projeto. Os conteúdos do arquivo são os seguintes. 1. Quando o aplicativo é executado no Amazon Managed Service for Apache Flink, o comportamento padrão carrega a configuração do aplicativo a partir das propriedades de runtime que você definirá no aplicativo Amazon Managed Service for Apache Flink. Consulte [Crie e configure o aplicativo do Managed Service for Apache Flink](#get-started-exercise-7). ``` private static Map loadApplicationProperties(StreamExecutionEnvironment env) throws IOException { if (env instanceof LocalStreamEnvironment) { LOGGER.info("Loading application properties from '{}'", LOCAL_APPLICATION_PROPERTIES_RESOURCE); return KinesisAnalyticsRuntime.getApplicationProperties( BasicStreamingJob.class.getClassLoader() .getResource(LOCAL_APPLICATION_PROPERTIES_RESOURCE).getPath()); } else { LOGGER.info("Loading application properties from Amazon Managed Service for Apache Flink"); return KinesisAnalyticsRuntime.getApplicationProperties(); } } ``` + O método `main()` define o fluxo de dados do aplicativo e o executa. + Inicializa os ambientes de transmissão padrão. Neste exemplo, mostramos como criar tanto `StreamExecutionEnvironment` a ser usada com a DataSteam API quanto `StreamTableEnvironment` a ser usada com SQL e a API de tabela. Os dois objetos de ambiente são duas referências separadas ao mesmo ambiente de tempo de execução, para uso diferente APIs. ``` StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); ``` + Carregue os parâmetros de configuração do aplicativo. Isso os carregará automaticamente a partir do local correto, dependendo de onde o aplicativo está sendo executado: ``` Map applicationParameters = loadApplicationProperties(env); ``` + O aplicativo define uma fonte usando o conector [Kinesis Consumer](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-consumer) para ler dados do fluxo de entrada. A configuração do fluxo de entrada é definido em `PropertyGroupId`=`InputStream0`. O nome e a região do fluxo estão nas propriedades nomeadas `stream.name` e `aws.region`, respectivamente. Para simplificar, essa fonte lê os registros como string. ``` private static FlinkKinesisConsumer createSource(Properties inputProperties) { String inputStreamName = inputProperties.getProperty("stream.name"); return new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(), inputProperties); } ... public static void main(String[] args) throws Exception { ... SourceFunction source = createSource(applicationParameters.get("InputStream0")); DataStream input = env.addSource(source, "Kinesis Source"); ... } ``` + Em seguida, o aplicativo define um coletor usando o conector [Kinesis Streams Sink](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-streams-sink) para enviar dados para o fluxo de saída. O nome e a região do fluxo de saída são definidos em `PropertyGroupId`=`OutputStream0`, semelhante ao fluxo de entrada. O coletor é conectado diretamente ao `DataStream` interno que está recebendo dados da fonte. Em um aplicativo real, há alguma transformação entre fonte e coletor. ``` private static KinesisStreamsSink createSink(Properties outputProperties) { String outputStreamName = outputProperties.getProperty("stream.name"); return KinesisStreamsSink.builder() .setKinesisClientProperties(outputProperties) .setSerializationSchema(new SimpleStringSchema()) .setStreamName(outputStreamName) .setPartitionKeyGenerator(element -> String.valueOf(element.hashCode())) .build(); } ... public static void main(String[] args) throws Exception { ... Sink sink = createSink(applicationParameters.get("OutputStream0")); input.sinkTo(sink); ... } ``` + Por fim, execute o fluxo de dados que acabou de definir. Essa deve ser a última instrução do método `main()` depois de definir todos os operadores que o fluxo de dados exige: ``` env.execute("Flink streaming Java API skeleton"); ``` ### Usar o arquivo pom.xml O arquivo pom.xml define todas as dependências exigidas pelo aplicativo e configura o plug-in Maven Shade para criar o fat-jar que contém todas as dependências exigidas pelo Flink. + Algumas dependências têm escopo `provided`. Essas dependências estão disponíveis automaticamente quando o aplicativo é executado no Amazon Managed Service for Apache Flink. Eles são necessários para compilar o aplicativo ou para executá-lo localmente em seu IDE. Para obter mais informações, consulte [Execute o aplicativo localmente](#get-started-exercise-5-run). Verifique se você está usando a mesma versão do Flink que o runtime que você usará no Amazon Managed Service for Apache Flink. ``` org.apache.flink flink-clients ${flink.version} provided org.apache.flink flink-streaming-java ${flink.version} provided ``` + Você deve adicionar dependências extra do Apache Flink ao pom com o escopo padrão, como o [conector Kinesis](https://nightlies.apache.org/flink/flink-docs-master/docs/connectors/datastream/kinesis/) usado por esse aplicativo. Para obter mais informações, consulte [Use os conectores do Apache Flink](how-flink-connectors.md). Você também pode adicionar quaisquer dependências Java adicionais exigidas pelo aplicativo. ``` org.apache.flink flink-connector-kinesis ${aws.connector.version} ``` + O plug-in Maven Java Compiler garante que o código seja compilado em Java 11, a versão do JDK atualmente suportada pelo Apache Flink. + O plug-in Maven Shade empacota o fat-jar, excluindo algumas bibliotecas que são fornecidas pelo runtime. Também especifica dois transformadores: `ServicesResourceTransformer` e `ManifestResourceTransformer`. O último configura a classe que contém o método `main` para iniciar o aplicativo. Se você renomear a classe principal, não se esqueça de atualizar esse transformador. + ``` org.apache.maven.plugins maven-shade-plugin ... com.amazonaws.services.msf.BasicStreamingJob ... ``` ## Gravação de registros de amostra no fluxo de entrada Nesta seção, você enviará amostras de registros para o fluxo a serem processados pelo aplicativo. Você tem duas opções para gerar dados de amostra, usando um script Python ou o [Kinesis Data Generator](https://github.com/awslabs/amazon-kinesis-data-generator). ### Gerar dados de amostra usando um script Python É possível usar um script Python para enviar registros de amostra para o fluxo. **nota** Para executar esse script do Python, você deve usar o Python 3.x e ter a biblioteca [AWS SDK para Python (Boto)](https://aws.amazon.com/developer/language/python/) instalada. **Para começar a enviar dados de teste para o fluxo de entrada do Kinesis:** 1. Baixe o script `stock.py` Python do gerador de dados no repositório do [gerador GitHub de dados](https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples/tree/main/python/data-generator). 1. Execute o script `stock.py`: ``` $ python stock.py ``` Mantenha o script em execução enquanto você conclui o restante do tutorial. Agora você pode executar o aplicativo Apache Flink. ### Gerar dados de amostra usando o Kinesis Data Generator Como alternativa ao script Python, você pode usar o [Kinesis Data Generator](https://github.com/awslabs/amazon-kinesis-data-generator), também disponível em uma [versão hospedada](https://awslabs.github.io/amazon-kinesis-data-generator/web/producer.html), para enviar dados de amostra aleatórios para o fluxo. O Kinesis Data Generator é executado no seu navegador e você não precisa instalar nada na máquina. **Para configurar e executar o Kinesis Data Generator:** 1. Siga as instruções na [documentação do Kinesis Data Generator](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) para configurar o acesso à ferramenta. Você executará um CloudFormation modelo que configura um usuário e uma senha. 1. Acesse o Kinesis Data Generator por meio da URL gerada pelo CloudFormation modelo. Você pode encontrar o URL na guia **Saída** após a conclusão do CloudFormation modelo. 1. Configure o gerador de dados: + **Região:** selecione a região que utilizada neste tutorial: us-east-1 + **Fluxo/fluxo de entrega:** selecione o fluxo de entrada que o aplicativo usará: `ExampleInputStream` + **Registros por segundo:** 100 + **Modelo de registro:** copie e cole o modelo a seguir: ``` { "event_time" : "{{date.now("YYYY-MM-DDTkk:mm:ss.SSSSS")}}, "ticker" : "{{random.arrayElement( ["AAPL", "AMZN", "MSFT", "INTC", "TBV"] )}}", "price" : {{random.number(100)}} } ``` 1. Teste o modelo: selecione **Modelo de teste** e verifique se o registro gerado é semelhante ao seguinte: ``` { "event_time" : "2024-06-12T15:08:32.04800, "ticker" : "INTC", "price" : 7 } ``` 1. Inicie o gerador de dados: escolha **Selecionar dados a enviar**. O Kinesis Data Generator agora está enviando dados para o `ExampleInputStream`. ## Execute o aplicativo localmente É possível executar e depurar seu aplicativo Flink localmente em seu IDE. **nota** Antes de continuar, verifique se os fluxos de entrada e saída estão disponíveis. Consulte [Criar dois fluxos de dados do Amazon Kinesis](#get-started-exercise-1). Além disso, verifique se você tem permissão para ler e gravar em ambos os fluxos. Consulte [Autentique sua sessão AWS](#get-started-exercise-2-5). A configuração do ambiente de desenvolvimento local requer Java 11 JDK, Apache Maven e IDE para desenvolvimento em Java. Verifique se você atende aos pré-requisitos exigidos. Consulte [Atenda os pré-requisitos para concluir os exercícios](getting-started.md#setting-up-prerequisites). ### Importe o projeto Java para o IDE Para começar a trabalhar no aplicativo em seu IDE, você deve importá-lo como um projeto Java. O repositório que você clonou contém vários exemplos. Cada exemplo é um projeto separado. Para este tutorial, importe o conteúdo do subdiretório `./java/GettingStarted` para o seu IDE. Insira o código como um projeto Java existente usando o Maven. **nota** O processo exato para importar um novo projeto Java varia de acordo com o IDE utilizado. ### Verifique a configuração do aplicativo local Ao ser executado localmente, o aplicativo usa a configuração no arquivo `application_properties.json` na pasta de recursos do projeto sob `./src/main/resources`. Você pode editar esse arquivo para usar diferentes nomes ou regiões de fluxos do Kinesis. ``` [ { "PropertyGroupId": "InputStream0", "PropertyMap": { "stream.name": "ExampleInputStream", "flink.stream.initpos": "LATEST", "aws.region": "us-east-1" } }, { "PropertyGroupId": "OutputStream0", "PropertyMap": { "stream.name": "ExampleOutputStream", "aws.region": "us-east-1" } } ] ``` ### Defina a configuração de execução do IDE Você pode executar e depurar o aplicativo Flink diretamente do seu IDE executando a classe principal `com.amazonaws.services.msf.BasicStreamingJob`, da mesma forma que executaria qualquer aplicativo Java. Antes de executar o aplicativo, defina a configuração Run (Executar). A configuração depende do IDE utilizado. Por exemplo, consulte as [Configurações de execução/depuração](https://www.jetbrains.com/help/idea/run-debug-configuration.html) na documentação do IntelliJ IDEA. Em particular, você deve configurar o seguinte: 1. **Adicione as dependências `provided` ao classpath**. Isso é necessário para garantir que as dependências com escopo `provided` sejam passadas para o aplicativo quando executado localmente. Sem essa configuração, o aplicativo exibe um erro `class not found` imediatamente. 1. **Passe as AWS credenciais para acessar os streams do Kinesis** para o aplicativo. A maneira mais rápida é usar o [AWS Toolkit for IntelliJ IDEA](https://aws.amazon.com/intellij/). Usando esse plug-in do IDE na configuração Executar, você pode selecionar um AWS perfil específico. AWS a autenticação acontece usando esse perfil. Não é necessário passar as credenciais AWS diretamente. 1. Verifique se o IDE executa o aplicativo usando o **JDK 11**. ### Execute o aplicativo no IDE Depois de definir a configuração Executar para o `BasicStreamingJob`, você pode executar ou depurar como um aplicativo Java comum. **nota** Não é possível executar o fat-jar gerado pelo Maven diretamente com `java -jar ...` na linha de comando. Esse jar não contém as dependências principais do Flink necessárias para executar o aplicativo independentemente. Quando o aplicativo é iniciado com êxito, ele registra em log algumas informações sobre o minicluster autônomo e a inicialização dos conectores. Isso é acompanhado por vários registros de INFO e alguns de WARN que o Flink normalmente emite quando o aplicativo é iniciado. ``` 13:43:31,405 INFO com.amazonaws.services.msf.BasicStreamingJob [] - Loading application properties from 'flink-application-properties-dev.json' 13:43:31,549 INFO org.apache.flink.streaming.connectors.kinesis.FlinkKinesisConsumer [] - Flink Kinesis Consumer is going to read the following streams: ExampleInputStream, 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.cpu.cores required for local execution is not set, setting it to the maximal possible value. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.task.heap.size required for local execution is not set, setting it to the maximal possible value. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.task.off-heap.size required for local execution is not set, setting it to the maximal possible value. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.network.min required for local execution is not set, setting it to its default value 64 mb. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.network.max required for local execution is not set, setting it to its default value 64 mb. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.managed.size required for local execution is not set, setting it to its default value 128 mb. 13:43:31,677 INFO org.apache.flink.runtime.minicluster.MiniCluster [] - Starting Flink Mini Cluster .... ``` Depois que a inicialização for concluída, o aplicativo não emitirá mais nenhuma entrada de log. **Enquanto os dados estão fluindo, nenhum log é emitido.** Para verificar se o aplicativo está processando dados corretamente, você pode inspecionar os fluxos de entrada e saída do Kinesis, conforme descrito na seção a seguir. **nota** Não emitir logs sobre o fluxo de dados é o comportamento normal de um aplicativo Flink. A emissão de logs em cada registro pode ser conveniente para a depuração, mas pode adicionar uma sobrecarga considerável durante a execução na produção. ## Observe os dados de entrada e saída nos fluxos do Kinesis Você pode observar os registros enviados ao fluxo de entrada pelo Python (geração de amostra) ou pelo Kinesis Data Generator (link) usando o **Visualizador de dados** no console do Amazon Kinesis. **Para observar registros** 1. [Abra o console do Kinesis em https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. Verifique se a região é a mesma executada este tutorial, que é us-east-1 Leste dos EUA (Norte da Virgínia) por padrão. Altere a região se ela não corresponde. 1. Escolha **Fluxos de dados**. 1. Selecione o fluxo que deseja observar, `ExampleInputStream` ou `ExampleOutputStream.` 1. Selecione a guia **Visualizador de dados**. 1. Escolha qualquer **Fragmento**, mantenha **Último** como **Posição inicial** e, em seguida, escolha **Obter registros**. Talvez você veja o erro “Nenhum registro encontrado para esta solicitação”. Em caso afirmativo, escolha **Tentar obter registros novamente**. Os registros mais recentes publicados no fluxo são exibidos. 1. Selecione o valor na coluna Dados para inspecionar o conteúdo do registro no formato JSON. ## Interrompa seu aplicativo em execução localmente Interrompa o aplicativo em execução no IDE. O IDE geralmente fornece uma opção de “interromper”. A localização e o método exatos dependem do IDE utilizado. ## Compile e empacote o código do aplicativo Nesta seção, será usado o Apache Maven para compilar o código Java e empacotá-lo em um arquivo JAR. Você pode compilar e empacotar seu código usando a ferramenta de linha de comando do Maven ou o IDE. **Para compilar e empacotar usando a linha de comando do Maven:** Vá para o diretório que contém o GettingStarted projeto Java e execute o seguinte comando: ``` $ mvn package ``` **Para compilar e empacotar usando seu IDE:** Execute `mvn package` a partir da integração com o IDE Maven. Em ambos os casos, o seguinte arquivo JAR é criado: `target/amazon-msf-java-stream-app-1.0.jar`. **nota** A execução de um “projeto de compilação” a partir do seu IDE pode não criar o arquivo JAR. ## Faça upload do arquivo JAR do código do aplicativo Nesta seção, você faz o upload do arquivo JAR criado na seção anterior no bucket do Amazon Simple Storage Service (Amazon S3) criado no início deste tutorial. Se você não concluiu essa etapa, consulte o (link). **Para fazer upload do arquivo JAR do código do aplicativo** 1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Selecione o bucket que você criou anteriormente para o código do aplicativo. 1. Escolha **Carregar**. 1. Escolha **Adicionar arquivos**. 1. Navegue até o arquivo JAR gerado na etapa anterior: `target/amazon-msf-java-stream-app-1.0.jar`. 1. Escolha **Fazer upload** sem alterar nenhuma outra configuração. **Atenção** Selecione o arquivo JAR correto em `/java/GettingStarted/target/amazon-msf-java-stream-app-1.0.jar`. O diretório `target` também contém outros arquivos JAR que você não precisa carregar. ## Crie e configure o aplicativo do Managed Service for Apache Flink É possível criar e executar um aplicativo Managed Service for Apache Flink usando o console ou a AWS CLI. Para este tutorial, você usará o console. **nota** Quando você cria o aplicativo usando o console, seus recursos AWS Identity and Access Management (IAM) e do Amazon CloudWatch Logs são criados para você. Ao criar o aplicativo usando o AWS CLI, você cria esses recursos separadamente. **Topics** + [ ### Criar a aplicação ](#get-started-exercise-7-console-create) + [ ### Editar a política do IAM ](#get-started-exercise-7-console-iam) + [ ### Configure o aplicativo ](#get-started-exercise-7-console-configure) + [ ### Execute o aplicativo ](#get-started-exercise-7-console-run) + [ ### Observe as métricas do aplicativo em execução ](#get-started-exercise-7-console-stop) + [ ### Observe os dados de saída nos fluxos do Kinesis ](#get-started-exercise-7-console-output) + [ ### Interromper o aplicativo ](#get-started-exercise-stop) ### Criar a aplicação **Para criar o aplicativo** 1. Faça login no e abra Console de gerenciamento da AWS o console Amazon MSF em https://console.aws.amazon.com /flink. 1. Verifique se a região correta está selecionada: us-east-1 Leste dos EUA (Norte da Virgínia) 1. Abra o menu à direita e escolha **aplicativos Apache Flink** e, em seguida, **Criar aplicativo de transmissão**. Como alternativa, escolha **Criar aplicativo de transmissão** no contêiner Get Started da página inicial. 1. Na página **Criar aplicativo de transmissão**: + **Selecione um método para configurar o aplicativo de processamento de fluxo:** escolha **Criar do zero**. + **Configuração do Apache Flink, versão do aplicativo Flink:** escolha **Apache Flink 1.20**. 1. Configure seu aplicativo + **Nome do aplicativo:** insira **MyApplication**. + **Descrição:** insira **My java test app**. + **Acesso aos recursos do aplicativo:** escolha **Criar/atualizar o perfil do IAM `kinesis-analytics-MyApplication-us-east-1` com as políticas necessárias**. 1. Configure seu **Modelo para as configurações do aplicativo** + **Modelos:** selecione **Desenvolvimento**. 1. Escolha **Criar aplicativo de transmissão** na parte inferior da página. **nota** Ao criar um aplicativo Managed Service for Apache Flink usando o console, você tem a opção de ter um perfil do IAM e uma política criada para seu aplicativo. O aplicativo usa essa função e política para acessar os recursos dependentes. Esses recursos do IAM são nomeados usando o nome do aplicativo e a região da seguinte forma: Política: `kinesis-analytics-service-MyApplication-us-east-1` Função: `kinesisanalytics-MyApplication-us-east-1` Anteriormente, o Amazon Managed Service for Apache Flink era conhecido como Kinesis Data Analytics. O nome dos recursos que são criados automaticamente recebe o prefixo `kinesis-analytics-` para compatibilidade com versões anteriores. ### Editar a política do IAM Edite a política do IAM para adicionar permissões de acesso aos fluxos de dados do Kinesis. **Para editar a política** 1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Selecione **Políticas**. Selecione a política **`kinesis-analytics-service-MyApplication-us-east-1`** que o console criou na seção anterior. 1. Escolha a guia **Edit (Editar)** e escolha a guia **JSON**. 1. Adicione a seção destacada do exemplo de política a seguir à política. Substitua a conta de amostra IDs (*012345678901*) pelo ID da sua conta. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "ReadCode", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Resource": [ "arn:aws:s3:::my-bucket/kinesis-analytics-placeholder-s3-object" ] }, { "Sid": "ListCloudwatchLogGroups", "Effect": "Allow", "Action": [ "logs:DescribeLogGroups" ], "Resource": [ "arn:aws:logs:us-east-1:012345678901:log-group:*" ] }, { "Sid": "ListCloudwatchLogStreams", "Effect": "Allow", "Action": [ "logs:DescribeLogStreams" ], "Resource": [ "arn:aws:logs:us-east-1:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*" ] }, { "Sid": "PutCloudwatchLogs", "Effect": "Allow", "Action": [ "logs:PutLogEvents" ], "Resource": [ "arn:aws:logs:us-east-1:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream" ] }, { "Sid": "ReadInputStream", "Effect": "Allow", "Action": "kinesis:*", "Resource": "arn:aws:kinesis:us-east-1:012345678901:stream/ExampleInputStream" }, { "Sid": "WriteOutputStream", "Effect": "Allow", "Action": "kinesis:*", "Resource": "arn:aws:kinesis:us-east-1:012345678901:stream/ExampleOutputStream" } ] } ``` ------ 1. Escolha **Avançar** na parte inferior da página e **Salvar alterações**. ### Configure o aplicativo Edite a configuração do aplicativo para definir o artefato do código do aplicativo. **Para editar a configuração** 1. Na **MyApplication**página, escolha **Configurar**. 1. Na seção **Localização do código do aplicativo**: + Para o **bucket do Amazon S3**, selecione o bucket criado anteriormente para o código do aplicativo. Escolha **Procurar**, selecione o bucket correto e, em seguida, selecione **Escolher**. Não clique no nome do bucket. + Em **Caminho do objeto do Amazon S3**, insira **amazon-msf-java-stream-app-1.0.jar**. 1. Em **Permissões de acesso**, selecione **Criar/atualizar o perfil do IAM `kinesis-analytics-MyApplication-us-east-1` com as políticas necessárias**. 1. Na seção **Propriedades do runtime**, adicione as propriedades a seguir. 1. Selecione **Adicionar novo item** e adicione cada um dos seguintes parâmetros: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/managed-flink/latest/java/get-started-exercise.html) 1. Não modifique nenhuma das outras seções. 1. Escolha **Salvar alterações**. **nota** Quando você opta por ativar o CloudWatch registro na Amazon, o Managed Service for Apache Flink cria um grupo de logs e um stream de logs para você. Os nomes desses recursos são os seguintes: Grupo de logs: `/aws/kinesis-analytics/MyApplication` Fluxo de logs: `kinesis-analytics-log-stream` ### Execute o aplicativo Agora o aplicativo está configurado e pronto para execução. **Executar o aplicativo** 1. No console do Amazon Managed Service for Apache Flink, escolha **Meu aplicativo** e escolha **Executar**. 1. Na próxima página, que é a página de configuração de restauração do aplicativo, escolha **Executar com o snapshot mais recente** e, em seguida, escolha **Executar**. O **Status** nos **Detalhes do aplicativo** muda de `Ready` para `Starting` e depois para `Running` quando o aplicativo é iniciado. Quando o aplicativo está no status `Running`, aí é possível abrir o painel do Flink. **Para abrir o painel do** 1. Selecione **Abrir painel do Apache Flink**. O painel é aberto em uma nova página. 1. Na lista **Trabalhos em execução**, escolha o único trabalho exibido. **nota** Se você definiu as propriedades do Runtime ou editou as políticas do IAM incorretamente, o status do aplicativo pode se transformar em `Running`, mas o painel do Flink mostra que o trabalho está sendo reiniciado continuamente. Esse é um cenário de falha comum se o aplicativo estiver configurado incorretamente ou não tiver permissões para acessar recursos externos. Quando isso acontecer, verifique a guia **Exceções** no painel do Flink para verificar a causa do problema. ### Observe as métricas do aplicativo em execução Na **MyApplication**página, na seção de ** CloudWatch métricas da Amazon**, você pode ver algumas das métricas fundamentais do aplicativo em execução. **Para visualizar as métricas** 1. Ao lado do botão **Atualizar**, selecione **10 segundos** na lista suspensa. 1. Quando o aplicativo está em execução e íntegro, é possível ver a métrica de **tempo de atividade** aumentando continuamente. 1. A métrica **fullrestarts** deve ser zero. Se estiver aumentando, a configuração pode ter problemas. Para investigar o problema, revise a guia **Exceções** no painel do Flink. 1. A métrica **Número de pontos de verificação com falha** deve ser zero em um aplicativo íntegro. **nota** Esse painel exibe um conjunto fixo de métricas com uma granularidade de 5 minutos. Você pode criar um painel de aplicativos personalizado com qualquer métrica no CloudWatch painel. ### Observe os dados de saída nos fluxos do Kinesis Verifique se você ainda está publicando dados na entrada, usando o script Python ou o Kinesis Data Generator. Agora você pode observar a saída do aplicativo em execução no Managed Service for Apache Flink usando o Visualizador de Dados no [https://console.aws.amazon.com/kinesis/](https://console.aws.amazon.com/kinesis/), da mesma forma que você já fez anteriormente. **Para visualizar a saída** 1. [Abra o console do Kinesis em https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. Verifique se a região é a mesma utilizada para executar este tutorial. Por padrão, é us-east-1 Leste dos EUA (Norte da Virgínia). Altere a região se necessário. 1. Escolha **Fluxos de dados**. 1. Selecione o fluxo que deseja observar. Para este tutorial, use `ExampleOutputStream`. 1. Selecione a guia **Visualizador de dados**. 1. Selecione qualquer **Fragmento**, mantenha **Último** como **Posição inicial** e, em seguida, escolha **Obter registros**. Talvez você veja o erro “Nenhum registro encontrado para esta solicitação”. Em caso afirmativo, escolha **Tentar obter registros novamente**. Os registros mais recentes publicados no fluxo são exibidos. 1. Selecione o valor na coluna Dados para inspecionar o conteúdo do registro no formato JSON. ### Interromper o aplicativo Para interromper o aplicativo, acesse a página do console do aplicativo do Managed Service for Apache Flink, `MyApplication`. **Como interromper o aplicativo** 1. Na lista suspensa **Ação**, escolha **Interromper**. 1. O **Status** nos **Detalhes do aplicativo** muda de `Running` para `Stopping` e depois para `Ready` quando o aplicativo é completamente interrompido. **nota** Não se esqueça também de parar de enviar dados para o fluxo de entrada a partir do script Python ou do Kinesis Data Generator. ## Próxima etapa [Limpe AWS os recursos](getting-started-cleanup.md) # Limpe AWS os recursos Esta seção inclui procedimentos para limpar AWS os recursos criados neste tutorial de introdução (DataStream API). **Topics** + [ ## Exclua o seu aplicativo Managed Service for Apache Flink ](#getting-started-cleanup-app) + [ ## Exclua seus fluxos de dados do Kinesis ](#getting-started-cleanup-stream) + [ ## Exclua seus objetos e bucket do Amazon S3 ](#getting-started-cleanup-s3) + [ ## Exclua seus recursos do IAM ](#getting-started-cleanup-iam) + [ ## Exclua seus CloudWatch recursos ](#getting-started-cleanup-cw) + [ ## Explorar recursos adicionais para o Apache Flink ](#getting-started-cleanup-next-step-5) ## Exclua o seu aplicativo Managed Service for Apache Flink Siga o procedimento a seguir para excluir o aplicativo. 1. [Abra o console do Kinesis em https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis) 1. No painel Managed Service for Apache Flink, escolha. **MyApplication** 1. Na lista suspensa **Ações**, selecione **Excluir** e confirme a exclusão. ## Exclua seus fluxos de dados do Kinesis 1. Faça login no e abra Console de gerenciamento da AWS o console Amazon MSF em https://console.aws.amazon.com /flink.. 1. Escolha **Fluxos de dados**. 1. Selecione os dois fluxos criados, `ExampleInputStream` e `ExampleOutputStream`. 1. Na lista suspensa **Ações**, selecione **Excluir** e confirme a exclusão. ## Exclua seus objetos e bucket do Amazon S3 Siga os procedimentos a seguir para excluir objetos e bucket do Amazon S3. **Para excluir o objeto de um bucket do S3** 1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Selecione o bucket do S3 que criado para o artefato do aplicativo. 1. Selecione o artefato do aplicativo que você carregou, chamado `amazon-msf-java-stream-app-1.0.jar`. 1. Selecione **Excluir** para confirmar a exclusão. **Para excluir o bucket do S3** 1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Selecione o bucket criado para os artefatos. 1. Selecione **Excluir** para confirmar a exclusão. **nota** Para ser excluído, o bucket do S3 deve estar vazio. ## Exclua seus recursos do IAM **Excluir seus recursos do IAM** 1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Na barra de navegação, selecione **Políticas**. 1. No controle do filtro, insira **kinesis**. 1. Escolha a política **kinesis-analytics-service- MyApplication -us-east-1**. 1. Selecione **Ações da política** e, em seguida, **Excluir**. 1. Na barra de navegação, selecione **Roles (Funções)**. 1. Escolha a função **kinesis-analytics- MyApplication** -us-east-1. 1. Selecione **Excluir função** e, em seguida, confirme a exclusão. ## Exclua seus CloudWatch recursos 1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação, selecione **Logs**. 1. Escolha o grupo**/aws/kinesis-analytics/MyApplication**log. 1. Selecione **Excluir grupo de logs** e, em seguida, confirme a exclusão. ## Explorar recursos adicionais para o Apache Flink [Explorar recursos adicionais](getting-started-next-steps.md) # Explorar recursos adicionais Agora que você criou e executou um aplicativo básico do Managed Service for Apache Flink, consulte os seguintes recursos para obter soluções mais avançadas de Managed Service for Apache Flink. + **[Workshop do Amazon Managed Service para Apache Flink](https://catalog.workshops.aws/managed-flink):** Neste workshop, você cria uma arquitetura de end-to-end streaming para ingerir, analisar e visualizar dados de streaming quase em tempo real. Você decidiu melhorar as operações de uma empresa de táxi na cidade de Nova York. Você analisa os dados de telemetria de uma frota de táxis na cidade de Nova York quase em tempo real para otimizar as operações da frota. + **[Exemplos de como criar e trabalhar com aplicativos no Managed Service for Apache Flink.](examples-collapsibles.md):** Esta seção deste Guia do desenvolvedor fornece exemplos de como criar e trabalhar com aplicativos no Managed Service for Apache Flink. Eles incluem exemplos de código e step-by-step instruções para ajudar você a criar serviços gerenciados para aplicativos Apache Flink e testar seus resultados. + **[Conheça o Flink: treinamento prático](https://nightlies.apache.org/flink/flink-docs-release-1.19/docs/learn-flink/overview/):** Treinamento introdutório oficial do Apache Flink que ajuda você a começar a escrever ETL de transmissão escalável, analytics e aplicativos orientados a eventos.