O que são as classes de armazenamento do Amazon S3? O Amazon S3 (Simple Storage Service) provê uma forma estratégica em organizar os objetos em diferentes camadas, onde cada camada possui suas particularidades que iremos detalhar mais a frente. As classes de armazenamento tem como características oferecer diferentes níveis de durabilidade, disponibilidade, desempenho e custos. Para isso, deve entender bem qual estratégia utilizar para manter os objetos visando o melhor custo benefício. A seguir, iremos detalhar cada classes, descrevendo suas vantagens de desvantagens. S3 Standard A classe de armazenamento S3 Standard é a opção padrão e mais utilizada do Amazon S3. Ela é projetada para oferecer alta durabilidade, disponibilidade e desempenho para objetos frequentemente acessados. Vantagens S3 Standard é a classe mais comum utilizada no armazenamento e acesso a objetos com maior frequência, pois é a camada que oferece baixa latência e isso permite ser usado por diferentes casos de usos onde o acesso dinâmico aos objetos é imprescindível. Outra vantagem é a durabilidade de 99.999999999%, ou seja, as chances dos objetos serem corrompidos ou até perdidos é muito baixa. Quanto a disponibilidade, esta classe fornece um SLA de 99,99%, significa que os objetos possuem uma alta disponibilidade para o acesso. Desvantagens S3 Standard possui algumas desvantagens comparado as outas classes. Uma delas é o alto custo de armazenamento para objetos pouco acessados. Por isso é importante definir políticas de ciclo de vida para lidar com objetos pouco acessados. No caso, existe a classe S3 Standard-Infrequent Access, que seria a mais apropriada para este contexto. Falaremos em breve sobre esta classe. Outra desvantagem está relacionada ao acesso a objetos recém-criados. Mesmo que esta classe possui como umas das principais características a baixa latência. Objetos recém-criados podem não estar disponíveis de imediato em todas as regiões, podendo levar um tempo para a disponibilidade dos objetos para algumas regiões, gerando uma alta latência S3 Intelligent-Tiering A classe de armazenamento S3 Intelligent-Tiering fornece um mecanismo em que possibilita mover objetos com base no padrão de uso de forma automática para camadas mais adequadas, visando baixo custos de armazenamento. Vantagens O próprio conceito já diz tudo sobre uma das vantagens de se usar S3 Intelligent-Tiering. Esta classe é capaz de gerenciar objetos com base no padrão de uso, ou seja, para aqueles objetos que são poucos acessados, a própria classe move para classes mais adequada visando menor custos de armazenamento. S3 Intelligent-Tiering monitora e move objetos de forma automática para camadas mais adequadas de acordo com o padrão de uso, geralmente esta integração funciona para 3 tipos de camadas. Uma camada otimizada para objetos de acessos frequentes, uma camada otimizada para objetos pouco acessados, que segundo a AWS gera uma economia de até 40%. E uma última camada direcionada a objetos que são raramente acessados, gerando uma economia de armazenamento em torno de 68%. Outro ponto de vantagem é que não existe cobrança por acesso aos dados utilizando S3-Intelligent-Tiering. Somente cobranças pelo armazenamento e transferência. Desvantagens Possível aumento na latência para objetos acessados pela primeira vez. O motivo é de que ao mover os objetos para camadas mais adequadas, existe a possibilidade do aumento de latência para estes objetos que são pouco acessados. S3 Standard-Infrequent Access (S3 Standard-IA) Classe adequada para armazenar objetos com acessos menos frequentes mas que precisam estar disponíveis para acessos rápidos, mantendo uma baixa latência. É uma típica classe para armazenar dados a longo prazo. Vantagens O custo de armazenamento é mais baixo se comparado a classe S3 Standard, mantendo as mesmas características de durabilidade. Sobre a disponibilidade dos dados, possui as mesmas características que a classe S3 Intelligent-Tiering, de 99.9% de SLA. E também, permite acesso rápido aos dados oferecendo uma alta taxa de vazão (throughput). A taxa mínima de armazenamento é cobrada mensalmente, diferente de classes como S3-Standard e S3-Intelligent Tiering. Desvantagens Não que necessariamente seja uma desvantagem, mas se comparado a outras classes pode não fazer tanto sentido, no caso, seria o custo de acesso aos dados. O acesso é cobrado por gigabyte acessado, ou seja, dependendo da frequência de acesso e volume acessado, seria melhor manter os dados em uma camada como S3 Standard. Tudo vai depender da sua estratégia. S3 One Zone-Infrequent Access (S3 One Zone-IA) Classe de armazenamento ideal para objetos que são acessados com pouca frequência e que estarão disponíveis em apenas uma zona (Availability Zone). A própria AWS sugere esta classe para cópias secundárias de backup de dados. Vantagens O custo é mais baixo comparada as demais classes de armazenamento, pois os dados serão armazenados em apenas uma zona, tornando o custo operacional baixo. Desvantagens Diferente das demais classes de armazenamento, onde o armazenamento dos objetos estão disponíveis em no mínimo 3 zonas de disponibilidade (AZ). A S3 One Zone-Infrequent Access disponibiliza os dados em somente 1 zona, fazendo com que não exista nenhum tipo de redundância, ou seja, existe uma possível chance na perda dos dados, caso haja alguma falha naquela determinada zona. S3 Glacier Instant Retrieval S3 Glacier Instant Retrieval faz parte da família Glacier, que tem como caraterística o baixo custo de armazenamento para objetos raramente acessados. É uma classe de armazenamento ideal para arquivamento de dados que necessita de acesso imediato. Vantagens O custo de armazenamento é baixo. Possui a mesma disponibilidade, comparado as classes S3 Intelligent-Tiering e S3 Standard-IA. Fornece redundância, ou seja, os dados são replicados para no mínimo 3 zonas de disponibilidades (AZ). Desvantagens Embora ofereça recuperação imediata dos dados mantendo a mesma vazão (throughput) do que classes como S3 Standard e S3 Standard-IA, o custo se torna alto quando é necessário a recuperação destes dados com uma grande frequência em um curto período. S3 Glacier Flexible Retrieval S3 Glacier Flexible Retrieval é a antiga classe de armazenamento chamada somente de S3 Glacier, possui uma característica em armazenar objetos com longa vida de duração, como qualquer outra classe da família Glacier. Esta classe é ideal para objetos que são acessado de 1 a 2 vezes ao ano e que requer recuperação de forma assíncrona, ou seja, sem acesso imediato. Vantagens Esta classe é ideal para manter objetos que não requer recuperação imediata, tornando uma vantagem quanto a custos. No caso, dados como backup, nos quais a recuperação é bem rara, esta classe não oferece custo de recuperação pela ideia da frequência de acessar estes dados ser bem perto de zero. Desvantagens Tempo de recuperação pode ser lento para alguns cenários. Como característica da própria classe, S3 Glacier Flexible Retrieval pode não atender quando seja necessário o acesso imediato aos dados. S3 Glacier Deep Archive Classe de armazenamento com o menor custo entre as classes da família Glacier. Ideal para armazenar dados que podem ser acessados de 1 a 2 vezes ao ano. A AWS sugere o uso desta classe para cenários onde temos que manter dados entre 8 a 10 anos visando atender regulamentos relacionados a compliance ou qualquer outro tipo de regra relacionada a retenção dos dados para longos períodos. Vantagens O menor custo entre as classes do mesmo segmento e com disponibilidade de 99.99%. Classe disponível em no mínimo 3 zonas de disponibilidade (AZ) e ideal para dados que requer longos períodos de retenção. Desvantagens Tempo de recuperação longo, ou seja, caso precise de uma recuperação rápida, este SLA não atenderá. Por ter uma característica em que o dado deve ser pouco acessado, o custo de recuperação pode ser mais alto, dependendo da frequência de acessos. Espero que tenha curtido!

Em alguns momentos precisamos criar um novo projeto por várias razões: estudo, trabalho ou testes. Existem uma série de ferramentas que nos ajudam nesse processo, nesse tutorial vou mostrar como podemos criar um novo projeto Spring Boot diretamente do Intellij IDEA. Para este tutorial estou utilizando a última versão do Intellij IDEA (2023.1). Criando o Projeto: A primeira etapa é criar o projeto, para isso podemos ir no seguinte caminho dentro da IDE: File > New > Project Logo após, você deve selecionar a opção Spring Initializr e preencher as informações do projeto: Nesta janela você pode preencher: Name: nome do seu projeto Location: local onde o projeto será salvo Language: linguagem de programação do projeto Type: tipo de gerenciador de pacotes que será utilizado Gradle ou Maven Group: nome da base de pacotes do projeto Artifact: nome do artefato Package name: nome da base de pacotes que será organizado o projeto Jdk: caminho para a jdk a ser utilizada no projeto Packaging: tipo de pacote que será gerado do projeto ao buildar, geralmente se utilizar o Jar Após preencher tudo cliente em NEXT. Na próxima tela você poderá selecionar quais frameworks serão utilizados, como por exemplo Spring Web: Selecione os frameworks que você deseja para seu projeto, em seguida clique em CREATE. Após isso seu projeto estará pronto. Pode começar a codar ! Links: Intellij IDEA - https://www.jetbrains.com/idea/

Quando estamos desenvolvendo microserviços, um dos itens que buscamos é ter serviços alto contidos. Dessa forma um dos pontos que costumam ficar de fora em vários casos é o banco de dados. Um framework que ajuda a versionar o banco dados através de scripts é o Flyway. O Flyway nos ajuda a tratar todas as mudanças que serão realizadas no banco de dados através de um projeto spring-boot. Ele faz uso de scripts SQL e alguns metadados para gerenciar o estado e as mudanças do banco de dados. A vantagem de utilizar tal framework é que qualquer um que esteja desenvolvendo no projeto vai ter o mesmo estado do banco de dados, geralmente uma cópia do banco de dados de desenvolvimento ou produção. Nesse artigo vou mostrar como configurar o Flyway em um projeto Spring Boot. Criando o projeto Para criar o projeto vamos utilizar o site oficial do Spring. Primeiramente acesse o site:: https://start.spring.io/ Quando a página estiver carregada, configure as informações conforme a imagem abaixo: Quando estiver finalizado basta clicar em GENERATE para baixar o projeto configurado. Assim que realizar o download, você pode importar para sua IDE preferida. Eu vou utilizar o Intellij Idea (https://www.jetbrains.com/idea/). Entendendo o Flyway Se você abrir o arquivo pom.xml, você irá ver a dependência do flyway-core: Dentro da estrutura do projeto você encontrará a pasta db.migration, nela vamos salvar os scripts do banco de dados. Quando o projeto iniciar uma das tarefas durante o processo de inicialização é verificar se há algum novo script no projeto, havendo qualquer script ele irá aplicar no banco de dados. Para criar nosso novo script, precisamos seguir alguns padrões no nome do arquivo. Esse padrão precisa ter um número que será incrementado a cada novo script. Dessa forma ajudamos o flyway a entender que se trata de um script não executado. Para simplificar esse tutorial vamos criar um simples script que irá seguir o padrão V1, V2, V3 para incrementar o arquivo. No final o nome é o seguinte: V1__create_base_tables.sql Criando nosso primeiro script Crie um novo arquivo chamado V1_create_base_tables.sql dentro da pasta db.migration e adicione o conteúdo abaixo: Configurando o banco de dados Para simplificar ainda mais o tutorial, eu utilizei o banco de dados H2 (banco em memória) para mostrar o funcionamento do flyway. Para configurar esse banco no nosso projeto, abra o arquivo pom.xml e adicione a seguinte dependência: Logo em seguida vamos colocar os dados para conexão no banco de dados. Dentro do arquivo application.properties adicione as seguintes configurações: Após isso podemos executar o projeto, nos logs vamos ver algo parecido com isso durante a execução: 2023-04-07 14:12:29.896 INFO 8012 --- [ main] o.f.c.i.database.base.BaseDatabaseType : Database: jdbc:h2:mem:testdb (H2 2.1) 2023-04-07 14:12:30.039 INFO 8012 --- [ main] o.f.core.internal.command.DbValidate : Successfully validated 1 migration (execution time 00:00.037s) 2023-04-07 14:12:30.055 INFO 8012 --- [ main] o.f.c.i.s.JdbcTableSchemaHistory : Creating Schema History table "PUBLIC"."flyway_schema_history" ... 2023-04-07 14:12:30.132 INFO 8012 --- [ main] o.f.core.internal.command.DbMigrate : Current version of schema "PUBLIC": << Empty Schema >> 2023-04-07 14:12:30.143 INFO 8012 --- [ main] o.f.core.internal.command.DbMigrate : Migrating schema "PUBLIC" to version "1 - create base tables" 2023-04-07 14:12:30.177 INFO 8012 --- [ main] o.f.core.internal.command.DbMigrate : Successfully applied 1 migration to schema "PUBLIC", now at version v1 (execution time 00:00.057s) 2023-04-07 14:12:30.477 INFO 8012 --- [ main] o.hibernate.jpa.internal.util.LogHelper : HHH000204: Processing PersistenceUnitInfo [name: default] Este log mostra que a execução da atualização do banco aconteceu com sucesso. Quando um novo script for adicionado, como por exemplo V2__new_tables.sql, o flyway irá executar somente o novo script V2. Observação: neste caso estamos utilizando um banco de dados em memória, toda vez que a aplicação parar, todos os dados contidos nela serão liberados. Portanto sempre iremos iniciar o banco do zero. Para os próximos tutoriais, vamos explorar cenários parecidos com casos reais. Conclusão O versionamento do banco de dados trás algumas vantagens como dar aos desenvolvedores uma cópia exata do banco de dados. Quando há alguma modificação a própria aplicação irá atualizar e gerenciar todas as mudanças, podendo aplicar tanto em desenvolvimento e produção. Referências Para mais detalhes você pode checar a documentação oficial do Spring: https://docs.spring.io/spring-boot/docs/current/reference/html/howto.html#howto.data-initialization.migration-tool.flyway Criando migrations: https://flywaydb.org/documentation/tutorials/baselineMigrations H2 database http://www.h2database.com/html/tutorial.html

Introdução AWS fornece diferentes maneiras de transformar dados por meio de seus serviços e um dos meus favoritos é o Kinesis Firehose Data Transformation. Essa é uma estratégia para transformar dados aproveitando o serviço de Streaming na entregar dos dados. Para este tutorial, vamos usar a estratégia abaixo. O Kinesis Firehose enviará dados e, em vez de escrever no S3, invocará um Lambda para transformar esses dados e, em seguida, enviá-los de volta ao Kinesis Firehose, que entregará os mesmos dados ao S3. Criando o projeto Para este post usaremos Java como linguagem e Maven como gerenciador de dependências. Portanto, é necessário gerar um projeto Maven que criará a estrutura do nosso projeto. Se você não sabe como gerar um projeto Maven, recomendo ler o post Gerando um projeto Maven sem IDE em 2 minutos, onde mostro como gerá-lo. Estrutura do projeto Após gerar o projeto Maven e importá-lo para sua IDE, vamos criar os mesmos arquivos e pacotes conforme imagem ao lado, exceto o pom.xml que foi criado pelo gerador maven. Dentro da pasta java, crie um pacote chamado coffee.tips.lambda e crie também uma classe Java chamada Handler.java dentro deste mesmo pacote. Agora, crie um pacote chamado model dentro do pacote coffee.tips e então, crie duas classes java: Record.java Records.java Por fim, crie um novo pacote chamado status e também crie um enum chamada Status. Criando a classe Record Por que precisamos da classe Record? Kinesis Firehose espera um objeto como retorno contendo os campos acima. Isso acontece quando o Kinesis Firehose invoca o Lambda para transformar os dados e o mesmo Lambda deve retornar um objeto contendo esses campos preenchidos. recordId Este valor de campo deve conter o mesmo id vindo do Kinesis result Esse valor de campo controla o resultado do status da transformação. Os valores possíveis são: Ok: Registro transformado com sucesso. Dropped: O registro rejeitado intencionalmente de acordo com sua lógica de processamento. ProcessingFailed: Os dados não puderam ser transformados. data Este campo deve conter os dados após serem convertidos usando o algoritmo de conversão base64. Este modelo deve conter os seguintes parâmetros. Caso contrário, o Kinesis Firehose rejeita e define como falha na transformação. Criando a classe Records A classe Records será nossa classe Java onde será utilizada como retorno na classe Handler.java onde abordaremos mais a frente, contendo uma lista do tipo Record. Criando o Enum Status Decidi criar o Enum acima apenas para criar um código mais elegante, mas é útil quando precisamos mapear valores diferentes para um contexto específico. Criando a classe Handler A classe Handler será nosso controlador para o Lambda. Este Lambda será invocado pelo Kinesis Firehose passando alguns parâmetros contendo os dados a serem transformados. Observe que, para o método handleRequest, um parâmetro chamado input do tipo KinesisFirehoseEvent contém os registros enviados pelo Kinesis Firehose e o mesmo método retornará um objeto do tipo Records contendo uma lista de registros que posteriormente serão enviados de volta ao Kinesis Firerose entregando ao S3. Dentro da iteração usando o Java Stream, criamos algumas condições apenas para explorar como o campo de result funciona. Dependendo da condição, definimos o valor do result como Dropped, o que significa que os dados não serão entregues ao Kinesis Firehose. Caso contrário, para aqueles que foram definidos como Ok, os dados serão enviados para o Kinesis Firehose. Outro detalhe é que você pode alterar os valores durante a execução. Definimos "TECH" como o valor para o campo TICKER_SYMBOL quando o valor do campo SECTOR for TECHNOLOGY. É uma forma de transformar dados aplicando uma certa logica. Por fim, foram criados outros dois métodos apenas para decodificar e codificar os dados como requisito para o bom funcionamento do processamento. Atualizando o arquivo pom.xml Após gerar nosso projeto via Maven, precisamos adicionar algumas dependências e um plugin para empacotar o código e as bibliotecas para implantação. Seguindo o conteúdo do pom.xml abaixo: Criando recursos via Terraform Em vez de criar o Kinesis Firehose, Lambda, policies e roles manualmente por meio do console, vamos criar por meio do Terraform. Se você não conhece muito sobre Terraform, recomendo ver este tutorial Primeiros passos utilizando Terraform na AWS. Dentro da pasta terraform, crie os seguintes arquivos: Conteúdo do arquivo vars.tf O arquivo vars.tf é onde declaramos as variáveis. As variáveis ​​fornecem flexibilidade quando precisamos trabalhar com recursos diferentes. Conteúdo do arquivo vars.tfvars Agora precisamos definir os valores dessas variáveis. Então, vamos criar uma pasta chamada development dentro da pasta terraform. Após a criação da pasta. Crie um arquivo chamado vars.tfvars como na imagem e cole o conteúdo abaixo. Observe o campo bucket, você deve especificar o nome do seu próprio bucket. O nome do bucket deve ser único. Conteúdo do arquivo main.tf Para este arquivo, apenas declaramos o Provider. Provider é o serviço de nuvem que usaremos para criar nossos recursos. Neste caso, estamos usando a AWS como provider e o Terraform fará o download dos pacotes necessários para criar os recursos. Observe que, para o campo region, estamos usando a palavra-chave var para atribuir o valor da região já declarado no arquivo vars.tfvars. Conteúdo do arquivo s3.tf Este arquivo é onde declaramos os recursos relacionados ao S3. Nesse caso, estamos criando apenas o bucket S3. Mas, se você deseja criar mais recursos relacionados ao S3, como policies, roles e etc, pode declará-lo aqui. Conteúdo do arquivo lambda.tf O conteúdo abaixo será responsável pela criação do AWS Lambda e suas roles e policies. Observe que no mesmo arquivo estamos criando um recurso chamado aws_s3_object. É uma estratégia carregar o arquivo Jar diretamente no S3 após o empacotamento. Manter alguns arquivos no S3 é uma forma inteligente quando trabalhamos com arquivos grandes. Entendendo o conteúdo do lambda.tf 1. Declaramos aws_iam_policy_document que descrevem quais ações os recursos que serão atribuídos a essas políticas podem executar. 2. aws_iam_role fornece a função IAM e controlará algumas ações do Lambda. 3. Declaramos o recurso aws_s3_object porque queremos armazenar nosso arquivo Jar que será criado no S3. Assim, durante a fase de implantação, o Terraform obterá o arquivo Jar que será criado na pasta target e fará o upload para o S3. depends_on: O recurso atual somente será criado caso o recurso atribuído neste campo, já estivesse sido criado. bucket: É o nome do bucket onde também irá armazenar o arquivo Jar. key: Nome do arquivo Jar. source: Localização do arquivo de origem. etag: Aciona atualizações quando o valor muda. 4. aws_lambda_function é o recurso responsável por criar o Lambda e precisamos preencher alguns campos como: function_name: nome Lambda. role: Função do Lambda declarada nas etapas anteriores que fornece acesso aos serviços e recursos da AWS. handler: Neste campo você precisa passar o caminho da classe principal. source_code_hash: Este campo é responsável por acionar as atualizações do lambda. s3_bucket: É o nome do bucket onde também irá armazenar o arquivo Jar gerado durante o deploy. s3_key: Nome do arquivo Jar. runtime: Aqui você pode definir a linguagem de programação suportada pelo Lambda. Para este exemplo, java 11. timeout: Tempo limite de execução do Lambda. Lembrando que o timeout máximo é de minutos. 5. aws_iam_policy fornece políticas IAM para os recursos onde definimos algumas ações a serem executadas. Nesse caso, definimos ações como invocação do Lambda e habilitação aos logs no CloudWatch. 6. Para o recurso aws_iam_role_policy_attachment, podemos anexar policies do IAM às roles. Nesse caso, anexamos as policies lambda_iam_role criadas anteriormente. 7. Finalmente, temos o recurso aws_lambda_permission. Precisamos desse recurso para dar permissão ao Kinesis Firehose para invocar o Lambda. Conteúdo do arquivo kinesis.tf Entendendo o conteúdo do kinesis.tf 1. Declaramos o recurso aws_kinesis_firehose_delivery_stream e seus campos, seguindo os detalhes: destination: Esse é o próprio destino, o Kinesis fornece um mecanismo para entregar dados ao S3(extended_s3), Redshift, Elasticsearch (OpenSearch serviço AWS), splunk e http_endpoint. name: Nome Kinesis Firehose. depends_on: O recurso atual somente será criado caso o recurso atribuído neste campo, já estivesse sido criado, ou seja, Kinesis Firehose será criado se o S3 Bucket já existir. extended_s3_configuration: 1. bucket_arn: S3 Bucket utilizando o prefixo arn. 2. role_arn: ARN role. 3. prefix: Pasta do S3 Bucket onde os dados serão armazenados. Você pode especificar o formato de pastas usando as seguintes expressões, "/year=! {timestamp:yyyy}/month=!{timestamp:MM}/". 4. error_output_prefix: Para este campo, você pode definir um caminho para armazenar os resultados da falha do processo. 5. buffer_interval: Buffer do Kinesis Firehose utilizando configurações de intervalo para a entrega do dado. 6. buffer_size: Buffer do Kinesis Firehose utilizando configurações de tamanho de dados para a entrega do dado. 7. compression_format: Existem algumas opções de formato de compactação como ZIP, Snappy, HADOOP SNAPPY e GZIP. Para este tutorial, escolhemos GZIP. processing_configuration:Esse é o bloco onde definimos qual recurso será processado. Para este caso, AWS Lambda. 1. enabled: true para habilitar e false para desabilitar. 2. type: Tipo do processador. No caso, Lambda. 3. parameter_value: Nome da função Lambda com prefixo arn. 2. Declaramos aws_iam_policy_document que descrevem quais ações os recursos que serão atribuídos a essas políticas podem executar. 3. aws_iam_role recurso que fornece a função do IAM para controlar algumas ações do Kinesis. 4. aws_iam_policy fornece IAM policies para os recursos onde definimos algumas ações a serem executadas. Nesse caso, definimos S3 e algumas ações do Lambda. 5. Para o recurso aws_iam_role_policy_attachment, podemos anexar policies do IAM às roles. Nesse caso, anexamos as policies firehose_iam_role e firehose_policies criadas anteriormente. Packaging Criamos nosso projeto Maven, classe Handler com arquivos Java e Terraform para criar nossos recursos na AWS. Agora, vamos executar os seguintes comandos para o deploy do nosso projeto. Primeiro, abra o terminal e verifique se você está no diretório raiz do projeto e execute o seguinte comando maven: mvn package O comando acima empacotará o projeto criando o arquivo Jar a ser implantado e carregado no S3. Para ter certeza, verifique a pasta target e veja se alguns arquivos foram criados, incluindo o arquivo lambda-kinesis-transform-1.0.jar. Executando Terraform Agora, vamos executar alguns comandos do Terraform. Dentro da pasta terraform, execute os seguintes comandos no terminal: terraform init O comando acima iniciará o terraform, baixando as bibliotecas do terraform e também validará os arquivos do terraform. Para o próximo comando, vamos executar o comando plan para verificar quais recursos serão criados. terraform plan -var-file=development/vars.tfvars Após a execução, você verá logs semelhantes no console: Por fim, podemos solicitar a criação dos recursos através do seguinte comando: terraform apply -var-file=development/vars.tfvars Após a execução, você deve confirmar para executar as ações, digite "sim". Agora a provisão foi concluída! Enviando mensagens Bem, agora precisamos enviar algumas mensagens para serem transformadas e vamos enviá-las via console do Kinesis Firehose. Obviamente existem outras formas de enviar, mas para este tutorial vamos enviar pela forma mais fácil. Abra o console do Kinesis Firehose, acesse a opção Delivery Stream conforme a imagem abaixo. Na seção Test with demo data, clique no botão Start sending demo data para iniciar o envio. Após clicar, as mensagens serão enviadas pelo Kinesis Firehose e de acordo com as configurações do buffer, o Kinesis levará 2 minutos para entregar os dados ou caso atinja 1 MIB em quantidade de dados. Vamos dar uma olhada no nosso Lambda e ver as métricas: Clique na guia Monitor e depois, na opção Metrics e observe que o Lambda está sendo invocado e não há erros. Resultado dos Dados Transformados Agora que sabemos que tudo está funcionando bem, vamos dar uma olhada nos dados transformados diretamente no Amazon S3. Vá e acesse o S3 Bucket criado. Observe que muitos arquivos foram criados. Vamos ler um deles e ver os dados transformados. Escolha um arquivo como na imagem abaixo e clique no botão Actions e depois na opção Query with S3 Select. Seguindo as opções selecionadas na imagem abaixo, clique no botão Run SQL query para ver o resultado. Com base na imagem acima, você pode ver que, de acordo com a classe Handler.java, definimos um algoritmo para descartar dados com valor do campo CHANGE menor que zero e para aqueles com valor de campo SECTOR igual a TECHNOLOGY, definiríamos o valor de campo TICKER_SYMBOL como TECH. Este foi um exemplo de como você pode transformar dados usando Kinesis Firehose Data Transformation e Lambda como um componente barato para transformar dados. Parar de enviar mensagens Você pode parar de enviar mensagens antes de destruir os recursos criados via Terraform procurando economizar dinheiro. Então, basta voltar ao console do Kinesis Firehose e clicar no botão Stop sending demo data. Destroy As cobranças da AWS ocorrerão se você não destruir esses recursos. Portanto, recomendo destruí-los evitando algumas cobranças desnecessárias. Para evitá-lo, execute o comando abaixo. terraform destroy -var-file=development/vars.tfvars Lembra que você precisa confirmar essa operação, ok? Conclusão Definitivamente, Kinesis Firehose não é apenas um serviço de Streaming. Existe flexibilidade integrando os serviços da AWS e a possibilidade de entregar dados para diferentes destinos possibilitando a transformação de dados e aplicando a lógica de acordo com o seu caso de uso. Repositório GitHub Livros para estudar e ler Se você deseja aprender mais sobre e atingir um alto nível de conhecimento, recomendo fortemente a leitura do(s) seguinte(s) livro(s): AWS Cookbook (Versão Inglês) é um guia prático contendo 70 receitas detalhadas sobre os recursos da AWS e como resolver diferentes desafios. É um livro bem escrito e de fácil entendimento cobrindo os principais serviços da AWS através de exemplos práticos. A AWS ou Amazon Web Services é o serviço de nuvem mais utilizando atualmente em todo o mundo, caso queira entender mais sobre o tema para ficar bem posicionado no mercado, recomendo fortemente o estudo. Recomendações de Setup Se você tem interesse em saber qual é o meu setup que uso para desenvolver meus tutoriais, segue: Notebook Dell Inspiron 15 15.6 Monitor LG Ultrawide 29WL500-29 Well that’s it, I hope you enjoyed it!

Para este post, vamos criar um AWS Lambda com Terraform e Java como linguagem de programação. Mas antes de tudo, você já ouviu falar de Lambda? Caso não, recomendo ver este post sobre Lambda. E sobre Terraform? Neste post eu mostro os primeiros passos usando Terraform, é só clicar aqui. A ideia deste post é criar um AWS Lambda que será trigado através do CloudWatch Events por meio de um agendamento automatizado usando uma expression cron. Normalmente, podemos criar qualquer recurso da AWS usando o console, mas aqui usaremos o Terraform como uma ferramenta IaC (Infraestrutura como código) que criará qualquer recurso necessário para executar nosso AWS Lambda. Como runtime ou linguagem de programação, escolhemos Java. Lembre-se de que você pode executar o Lambda usando diferentes linguagens de programação, como Java, Python, .NET, Node.js e muito mais. Mesmo que seja um projeto Java, a parte mais importante deste post é tentar entender sobre o Lambda e como você pode cria-lo através do Terraform. Introdução O Terraform será responsável por criar todos os recursos para este post, como o prórprio Lambda, roles, policies, CloudWatch Events e S3 Bucket, onde manteremos o arquivo JAR de nosso aplicativo. Nosso Lambda será invocado pelo CloudWatch Events a cada 3 minutos executando um método simples em Java no qual imprimirá uma mensagem. Você pode observar na imagem acima que estamos usando S3 para armazenar nosso pacote de implantação, arquivo JAR neste caso. É uma recomendação da AWS fazer upload de pacotes de implantação maiores diretamente para o S3, em vez de manter no próprio Lambda. Isso acontece pois o S3 oferece suporte para armazenar arquivos maiores. Não se preocupe em carregar arquivos manualmente, o Terraform também será responsável por fazer isso durante a fase de build. Criando o projeto Para este post vamos usar Java como linguagem e Maven como gerenciador de dependências. Portanto é necessário gerar um projeto Maven que irá criar a estrutura do nosso projeto. Se você não sabe como gerar um projeto Maven, recomendo ver este tutorial onde mostro como gerar. Estrutura do projeto Após gerar o projeto Maven, vamos criar os mesmos arquivos e pacotes conforme imagem ao lado, exceto o pom.xml que foi criado pelo gerador maven. É uma característica dos projetos Maven gerar essas estruturas de pastas como mostrado src/main/java/. Dentro da pasta java/, crie um pacote chamado coffee.tips.lambda e crie uma classe Java chamada Handler.java dentro deste mesmo pacote. Alterando o pom.xml Para este tutorial, adicione as seguintes dependências e também copie a fase de build abaixo: Criando o Handler Uma classe handler é basicamente o controlador Lambda. O Lambda sempre procura um handler para iniciar seu processo, resumindo, é o primeiro código a ser invocado. Criamos um handler básico apenas para "printar" mensagens quando invocadas pelo CloudWatch Events. Obeserve que implementamos a interface RequestHandler permitindo receber como parâmetro um objeto Map. Mas para este exemplo não vamos explorar os dados deste parâmetro. Entendendo os arquivos Terraform Agora vamos entender como os recursos serão criados usando o Terraform. vars.tf No arquivo vars.tf é onde declaramos as variáveis. As variáveis ​​fornecem flexibilidade quando precisamos trabalhar com diferentes recursos e ambientes de execução. vars.tfvars Agora precisamos definir os valores dessas variáveis. Então, vamos criar uma pasta chamada /development dentro da pasta terraform. Após a criação da pasta. Crie um arquivo chamado vars.tfvars como na imagem ao lado e cole o conteúdo abaixo. Observe que no campo for bucket, você deve especificar o nome do seu próprio bucket. O nome do bucket deve ser único. main.tf Para o arquivo main.tf, apenas declaramos o provedor. Provider é o serviço de nuvem que usaremos para criar nossos recursos. Neste caso, estamos usando a AWS como provider e o Terraform fará o download dos pacotes necessários para criar os recursos. Observe que, para o campo region, estamos usando a palavra-chave var para obter o valor da região já declarado no arquivo vars.tfvars. s3.tf É no s3.tf que vamos declarar os recursos relacionados ao S3 em geral. Nesse caso, criamos apenas o bucket S3. Mas se você quiser criar mais recursos relacionados ao S3, como policies, roles ou qualquer recurso relacionado, pode declarar aqui. É uma forma de separar os arquivos Terraform por recurso. Observe novamente que estamos usando a palavra-chave var para a variável bucket declarada no arquivo var.tf. lambda.tf Finalmente nosso último arquivo terraform, neste arquivo estamos declarando recursos relacionados ao Lambda e ao próprio Lambda. Agora acho que vale a pena explicar alguns detalhes sobre o arquivo acima. 1. Declaramos 2 objetos do tipo data aws_iam_policy_document, que definem quais ações os recursos que serão atribuídos a essas policies podem executar. 2. aws_iam_role: recurso que fornece a função IAM e que também controlará algumas ações do Lambda. 3. aws_iam_role_policy: fornece IAM role inline policy e registrará a role e as policies anteriores relacionadas ao aws_iam_policy_document.aws_iam_policy_coffee_tips_aws_lambda_iam_policy_document. 4. Declaramos o recurso aws_s3_object porque queremos armazenar nosso arquivo jar no S3. Assim, durante a fase de deploy, o Terraform obterá o arquivo jar que será criado na pasta target/ do projeto e fará o upload para o S3. depends_on: Terraform deve criar este recurso antes do atual. bucket: É o nome do bucket onde irá armazenar o arquivo jar. key: nome da jar. source: localização do arquivo de origem. etag: aciona atualizações quando acontecem alterações. 5. aws_lambda_function is the resource responsible to create Lambda and we need to fill some fields such as: function_name: Nome do Lambda role: role declarada nas etapas anteriores que fornece acesso aos serviços e recursos da AWS. handler: Neste campo você precisa especificar o diretório da classe principal. source_code_hash: Este campo é responsável por acionar as atualizações do lambda. s3_bucket: É o nome do bucket onde irá armazenar o arquivo jar gerado durante o deploy. s3_key: Nome do jar runtime: Aqui você pode especificar a linguagem de programação suportada pelo Lambda. Para este exemplo, java 11. timeout: Tempo limite de execução do Lambda. 6. aws_cloudwatch_event_rule é a regra relacionada à execução do evento do CloudWatch. Neste caso, podemos definir o cron através do campo schedule_expression para definir quando o lambda será executado. Neste caso, definimos que o Lambda será executado a cada 2 minutos - rate(2 minutes), especificado no arquivo vars.tfvars. 7. aws_cloudwatch_event_target é o recurso responsável por acionar o Lambda usando eventos do CloudWatch. 8. aws_lambda_permission permite execuções do CloudWatch. Packaging Agora que você está familiarizado com o Lambda e o Terraform, vamos empacotar nosso projeto via Maven antes da criação do Lambda. A ideia é criar um arquivo jar que será usado para execuções do Lambda e armazenado no S3. Para este exemplo, vamos empacotar localmente. Vale lembrar que para um ambiente de produção, poderíamos utilizar ferramentas de integrações contínuas como Jenkins, Drone ou até Github actions para automatizar esse processo. Primeiro, abra o terminal e verifique se você está no diretório raiz do projeto e execute o seguinte comando maven: mvn clean install -U Este comando além de empacotar o projeto, irá baixar e instalar as dependências declaradas no arquivo pom.xml. Depois de executar o comando acima, um arquivo jar será gerado dentro da pasta target/ também criada. Executando Terraform Bem, estamos quase lá. Agora, vamos provisionar nosso Lambda via Terraform. Então, vamos executar alguns comandos do Terraform. Dentro da pasta terraform, execute os seguintes comandos no terminal: terraform init O comando acima iniciará o terraform, baixando as bibliotecas do terraform e também validará os arquivos do terraform. Para o próximo comando, vamos executar o comando plan para checar quais recursos serão criados. terraform plan -var-file=development/vars.tfvars Após a execução, você verá logs semelhantes no console: Por fim, podemos solicitar a criação definitiva dos recursos através do seguinte comando: terraform apply -var-file=development/vars.tfvars Após a execução, você deve confirmar para executar as ações, digite "sim". Agora a provisão foi concluída! Execução do Lambda Vá e acesse o console da AWS para ver a execução do Lambda que acabamos de criar. Acesse a aba monitor Acesse a aba Logs dentro da seção Monitor Veja as mensagens abaixo que serão impressas a cada 2 minutos. Destroy As cobranças de faturamento da AWS ocorrerão se você não destruir esses recursos. Portanto, recomendo destruí-los evitando algumas cobranças desnecessárias. Para evitar, execute o comando abaixo. terraform destroy -var-file=development/vars.tfvars Lembre-se que você precisa confirmar essa operação, ok? Conclusão Neste tutorial, criamos um AWS Lambda provisionado através do Terraform. Lambda é um serviço da AWS que podemos usar para diferentes casos de uso trazendo facilidade para compor uma arquitetura de software. Pudemos notar que o Terraform traz flexibilidade criando recursos para diferentes serviços em nuvem e fácil de implementar em projetos de softwares. Github repository Espero que tenha curtido!

O que é Maven? É comum ouvir falar em maven, principalmente para projetos Java mas não confunda Maven com Java, ok? Posso explicar o que é maven e seu caso de uso. Maven é uma ferramenta popular de automação de compilação usada principalmente para projetos Java. Ele fornece uma maneira estruturada de gerenciar dependências do projeto, criar processos e versões. O Maven usa uma abordagem declarativa para gerenciamento de projetos, onde você define as especificações e dependências do seu projeto em um arquivo XML chamado pom.xml (Project Object Model). O Maven ajuda a simplificar o processo de compilação gerenciando as dependências do seu projeto, baixando as bibliotecas necessárias dos repositórios e fornecendo uma maneira padronizada de criar e empacotar seu aplicativo. Ele também pode gerar documentação de projeto, executar testes e executar outras tarefas relacionadas à construção e gerenciamento de projetos Java. Para resumir, o Maven fornece um poderoso conjunto de ferramentas para criar, gerenciar e liberar aplicativos Java e é amplamente usado na comunidade de desenvolvimento Java. Gerando um projeto Maven sem IDE Normalmente, engenheiros geram o projeto Maven por meio de uma IDE, mas há maneiras mais fáceis de fazer o mesmo sem o suporte de IDEs Se você ainda não instalou o Maven, recomendo instalá-lo antes de começar. Assim, você pode baixar o Maven aqui neste link e depois de instalado, siga os passos para instalar utilizando este link aqui. Primeiramente, para ter certeza que você instalou o Maven, abra o terminal e execute o comando abaixo: mvn -version Uma mensagem semelhante à abaixo será exibida no terminal. Agora, vamos começar a gerar o nosso projeto Maven. 1° Passo: Abra o terminal novamente e execute o comando abaixo. mvn archetype:generate -DgroupId=com.coffeeantips.maven.app -DartifactId=coffeeantips-maven-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.0 -DinteractiveMode=false 2° Passo: Depois de executar o comando acima, uma pasta chamada coffeeantips-maven-app/ foi criada. Mude para este diretório e veremos a seguinte estrutura de pastas e arquivos. Entendendo os parâmetros do comando archetype:generate: Gera um novo projeto a partir de um archetype ou atualiza o projeto atual. -DgroupId: Especifica o pacote onde as pastas e arquivos de projetos serão gerados. -DartifactId: Nome ou artefato do projeto. -DarchetypeArtifactId: O Maven fornece uma lista de archetypes, você pode conferir aqui. Mas, para este exemplo, estamos usando um archetype para gerar um exemplo de projeto Maven padrão. -DarchetypeVersion: Versão do projeto. -DinteractiveMode: É uma maneira de definir se o Maven irá interagir com o usuário solicitando entradas(inputs). Material de estudo Se quer aprender mais sobre o assunto e alcançar um alto nível de conhecimento, recomendo fortemente a leitura do(s) seguinte(s) livro(s): Maven: The Definitive Guide (Versão Inglês) Escrito pelo criador do Maven, Jason Van Zyl, e sua equipe na Sonatype, Maven: The Definitive Guide explica claramente como essa ferramenta pode organizar seus projetos de desenvolvimento de software. Neste livro, você aprenderá sobre: ​​O POM e os relacionamentos do projeto, o ciclo de vida da construção, plug-ins, geração de sites do projeto, geração avançada de sites, relatórios, propriedades, perfis de construção, repositório Maven e muito mais. Bom é isso, espero que tenham gostado!

AWS Lambda é um serviço de computação sem servidor, também conhecido como Serverless. A execução do Lambda permite que você crie aplicativos de back-end usando diferentes linguagens de programação como Java, Python, Node.js, .Net, Ruby, Go e muito mais. A melhor parte do Lambda é que você não precisa se preocupar com servidores de aplicação para implantá-lo e executá-lo. Sem preocupações com as responsabilidades de capacidade de provisionamento que geralmente são utilizados em aplicações tradicionais como aplicações Web, onde requer o redimensionamento dependendo do tráfego, tornando-se uma alternativa mais barata para compor arquiteturas. Como funciona Lambdas também são usados ​​para compor arquiteturas sendo responsáveis ​​por cargas de trabalho específicas. Por exemplo, usando o Lambda, você pode começar a capturar/escutar arquivos de um S3 Bucket para efetuar algum tipo de normalização ou também pode usar o EventBridge (Cloudwatch events) criando agendamentos por meio de uma expressão cron para acionar o Lambda executando cargas de trabalho e depois encerrar o mesmo. Conforme mostrado na imagem abaixo, temos alguns exemplos de serviços que integram-se com o Lambda, dessa forma você pode usá-los para invocar os Lambdas para uma variedade de cenários. Limitações Lambdas podem ser executados por até 15 minutos, ou seja, seu timeout é de no máximo 15 minutos ou 900 segundos. Portanto, se for usá-lo, atente-se ao lidar com cargas de trabalho que levam mais de 15 minutos. Integrações Conforme mencionado anteriormente, o AWS Lambda permite que várias integrações de serviços sejam usadas como um gatilho/trigger. Se você deseja escutar objetos criados no S3 Bucket, pode usar o S3 como trigger. Se você precisar processar notificações do SNS, também poderá definir o Amazon Simple Notification Service (SNS) como o trigger e o Lambda receberá todas as notificações para serem processadas. Observe que temos diferentes cenários em que o Lambda pode resolver soluções com eficiência. Aqui você pode ver uma lista completa sobre os serviços integrados. Preços A AWS possui certas políticas sobre o uso de cada serviço. Lambdas são basicamente cobrados pelo número de requisições e pelo tempo de execução do código. Para mais detalhes, veja aqui. Casos de Uso Aqui teremos alguns exemplos onde o uso do Lambda pode ser uma opção interessante. Processamento de dados: imagine que você deve normalizar arquivos não estruturados em semi-estruturados para serem lidos por algum processo. Neste caso é possível escutar um Bucket S3 procurando por novos objetos para serem transformados usando o Lambda. Segurança: um Lambda que atualiza o Token de usuários de um aplicativo Transformação de dados: Você pode usar o Kinesis/Firehose como um gatilho. Neste caso, O Lambda ouvirá cada evento gerado pelo Kinesis, transformá-lo e enviá-lo de volta ao próprio Kinesis para que os dados possam ser entregues ao S3. Benefícios Preço: Pague apenas por requisições e tempo de execução do código Serverless: Não há necessidade de um servidor de aplicação Integrado: o Lambda fornece integração com boa parte dos serviços da AWS Linguagem de Programação: É possível utilizar as principais linguagens de programação Escala e concorrência: Permite controlar a concorrência e dimensionar o número de execuções até o limite da conta Material de estudo Se quer aprender mais sobre o assunto e alcançar um alto nível de conhecimento, recomendo fortemente a leitura do(s) seguinte(s) livro(s): AWS Cookbook (Versão Inglês) é um guia prático contendo 70 receitas detalhadas sobre os recursos da AWS e como resolver diferentes desafios. É um livro bem escrito e de fácil entendimento cobrindo os principais serviços da AWS através de exemplos práticos. A AWS ou Amazon Web Services é o serviço de nuvem mais utilizando atualmente em todo o mundo, caso queira entender mais sobre o tema para ficar bem posicionado no mercado, recomendo fortemente o estudo. Espero que tenha curtido!

O Delta Lake fornece uma maneira de controlar a versão dos dados para operações como merge, update e delete. Isso torna transparente o funcionamento do ciclo de vida dos dados gerenciados pelo próprio Delta Lake. Para cada operação, uma versão é incrementada e se você tiver uma tabela com múltiplas operações, diferentes versões de tabela serão criadas. Delta Lake oferece um mecanismo para navegar pelas diferentes versões chamado Time Travel. É uma forma temporária de acessar dados do passado. Para este Post, usaremos esse recurso para navegar por diferentes versões da tabela. Abaixo, temos uma Tabela Delta chamada people onde três versões foram geradas através de operações de escrita usando o modo append. Versão Atual Quando realizamos uma simples leitura em uma tabela, a versão atual é sempre a mais recente. Portanto, para este cenário, a versão atual é 2 (dois). Observe que não precisamos especificar qual versão queremos usar, porque ainda não estamos usando o Time Travel. session.read().format("delta").load("table/people") .orderBy("id").show(); Até aqui, nada mudou, vamos para os próximos passos. Trabalhando com Time Travel Agora vamos começar a explorar esta feature chamada Time Travel, para as próximas etapas, faremos leituras na tabela people especificando diferentes versões para entender como funciona esta feature. Leitura Tabela Delta - Versão 0 (zero) Como falado anteriormente, temos três versões dessa tabela, para o exemplo a seguir, vamos definir para que na leitura seja carregado dados da versão zero. session.read().format("delta") .option("versionAsOf", 0) .load("table/people") .orderBy("id").show(); Observe que adicionamos um novo parâmetro chamado versionAsOf , este parâmetro nos permite configurar o número da versão em que você deseja restaurar temporariamente para uma tabela. Para este cenário configuramos a leitura da Tabela Delta versão zero (0). Esta foi a primeira versão gerada pelo Delta Lake após a primeira operação de escrita. Leitura Tabela Delta - Versão 1(um) Para esta última etapa, estamos utilizando a versão um (1), observe que os dados da versão anterior (0) foram mantidos. session.read().format("delta") .option("versionAsOf", 1) .load("table/people") .orderBy("id").show(); Delta Lake fornece muitos benefícios e Time travel nos permite flexibilidade em uma arquitetura Big Data, para obter mais detalhes, recomendo ver as docs do Delta Lake. Material de estudo Se quer aprender mais sobre o assunto e alcançar um alto nível de conhecimento, recomendo fortemente a leitura do(s) seguinte(s) livro(s): Spark: The Definitive Guide: Big Data Processing Made Simple (Versão Inglês) é uma referência completa para quem quer aprender o Spark e sobre as suas principais funcionalidades. Lendo esse livro, você vai aprender sobre DataFrames, Spark SQL através de exemplos práticos. O autor mergulha nas APIs de baixo nível do Spark, RDDs e também sobre como o Spark é executado em um cluster e como depurar e monitorar os aplicativos de clusters do Spark. Os exemplos práticos estão em Scala e Python. Beginning Apache Spark 3: With Dataframe, Spark SQL, Structured Streaming, and Spark Machine Library (Versão Inglês) com a nova versão do Spark, este livro explora os principais recursos do Spark, como o uso de Dataframes, Spark SQL no qual você pode usar SQL para manipular dados e Structured Streaming para processar dados em tempo real. Este livro contém exemplos práticos e trechos de código para facilitar a leitura. High Performance Spark: Best Practices for Scaling and Optimizing Apache Spark (Versão Inglês) é um livro que explora as melhores práticas usando a linguagem Spark e Scala para lidar com aplicações de dados em larga escala, técnicas para transformações utilizando RDD, e também mostra como as novas interfaces do Spark SQL melhoram o desempenho sobre a estrutura de dados RDD do SQL, exemplos de Spark MLlib e o uso de bibliotecas de aprendizado de máquina de ML e muito mais. Python Crash Course, 2nd Edition: A Hands-On, Project-Based Introduction to Programming (Versão Inglês) abrange os conceitos básicos do Python por meio de exemplos interativos e práticas recomendadas. Learning Scala: Practical Functional Programming for the Jvm (Versão Inglês) é um excelente livro que aborda a linguagem Scala através de exemplos e exercícios práticos. Lendo este livro, você aprenderá sobre os principais tipos de dados, literais, valores e variáveis. Construir classes que compõem uma ou mais características para total reutilização, criar novas funcionalidades misturando-as na instanciação e muito mais. Scala é uma das principais linguagens em projetos de Big Data em todo o mundo, com grande uso em grandes empresas de tecnologia como o Twitter e também a linguagem principal do Spark. Bom é isso, espero que tenham gostado!

Para este post, vamos criar exemplos de como converter tabelas parquet em Delta table. Primeiro, criaremos uma tabela parquet do zero por meio de um Spark Dataframe e depois a converteremos em um Delta Table. O uso de Delta Table fornece benefícios em comparação com uma tabela em Parquet. O Delta permite restaurar versões de sua tabela por meio da função Time Travel, suporta transações ACID e várias outras features interessantes. Criando Tabela Parquet Em primeiro lugar, vamos criar uma tabela parquet para ser convertida posteriormente em uma Delta Table. Vamos criar uma tabela Parquet do início para um melhor entendimento. O código Java e Spark a seguir, será executado uma vez, apenas para criar uma tabela parquet. Vamos usar um Spark Dataframe que será carregado de um arquivo JSON contendo registros semi-estruturados. public static void main(String[] args){ SparkConf conf = new SparkConf(); conf.setAppName("spark-delta-table"); conf.setMaster("local[1]"); SparkSession session = SparkSession.builder() .config(conf) .getOrCreate(); Dataset dataFrame = session.read().json("product.json"); dataframe.write().format("parquet").save("table/product"); } No exemplo acima, começamos a criar um objeto SparkSession para criar e gerenciar um Spark Dataframe que foi carregado a partir do conteúdo do arquivo product.json. Após a carga, o Dataframe cria (ou escreve) uma tabela em formato parquet no diretório table/product. Conteúdo JSON Conteúdo representado pelo arquivo product.json que contém registros semi-estruturados. {"id":1, "name":"rice", "price":12.0, "qty": 2} {"id":2, "name":"beans", "price":7.50, "qty": 5} {"id":3, "name":"coke", "price":5.50, "qty": 2} {"id":4, "name":"juice", "price":3.80, "qty": 1} {"id":5, "name":"meat", "price":1.50, "qty": 1} {"id":6, "name":"ice-cream", "price":6.0, "qty": 2} {"id":7, "name":"potato", "price":3.70, "qty": 10} {"id":8, "name":"apple", "price":5.60, "qty": 5} Após executar o código acima, os arquivos parquets serão gerados no diretório table/product contendo o arquivo abaixo. Convertendo tabela Parquet em Delta Table Agora que temos uma tabela Parquet já criada, podemos converter facilmente para Delta Table, veja o código a seguir. public static void main(String[] args){ SparkConf conf = new SparkConf(); conf.setAppName("spark-delta-table"); conf.setMaster("local[1]"); SparkSession session = SparkSession.builder() .config(conf) .getOrCreate(); DeltaTable.convertToDelta(session, "parquet.`table/product`"); } O método DeltaTable.convertToDelta é responsável por converter a tabela parquet em Delta Table. Observe que tivemos que usar SparkSession como parâmetro e também especificar o caminho da tabela parquet usando este formato"parquet.``" . O resultado após a execução você pode ver na imagem abaixo. Após a execução da conversão, Delta cria o famoso diretório _delta_log contendo informações de commit e arquivos de checkpoint. Material de estudo Se quer aprender mais sobre o assunto e alcançar um alto nível de conhecimento, recomendo fortemente a leitura do(s) seguinte(s) livro(s): Spark: The Definitive Guide: Big Data Processing Made Simple (Versão Inglês) é uma referência completa para quem quer aprender o Spark e sobre as suas principais funcionalidades. Lendo esse livro, você vai aprender sobre DataFrames, Spark SQL através de exemplos práticos. O autor mergulha nas APIs de baixo nível do Spark, RDDs e também sobre como o Spark é executado em um cluster e como depurar e monitorar os aplicativos de clusters do Spark. Os exemplos práticos estão em Scala e Python. Beginning Apache Spark 3: With Dataframe, Spark SQL, Structured Streaming, and Spark Machine Library (Versão Inglês) com a nova versão do Spark, este livro explora os principais recursos do Spark, como o uso de Dataframes, Spark SQL no qual você pode usar SQL para manipular dados e Structured Streaming para processar dados em tempo real. Este livro contém exemplos práticos e trechos de código para facilitar a leitura. High Performance Spark: Best Practices for Scaling and Optimizing Apache Spark (Versão Inglês) é um livro que explora as melhores práticas usando a linguagem Spark e Scala para lidar com aplicações de dados em larga escala, técnicas para transformações utilizando RDD, e também mostra como as novas interfaces do Spark SQL melhoram o desempenho sobre a estrutura de dados RDD do SQL, exemplos de Spark MLlib e o uso de bibliotecas de aprendizado de máquina de ML e muito mais. Python Crash Course, 2nd Edition: A Hands-On, Project-Based Introduction to Programming (Versão Inglês) abrange os conceitos básicos do Python por meio de exemplos interativos e práticas recomendadas. Learning Scala: Practical Functional Programming for the Jvm (Versão Inglês) é um excelente livro que aborda a linguagem Scala através de exemplos e exercícios práticos. Lendo este livro, você aprenderá sobre os principais tipos de dados, literais, valores e variáveis. Construir classes que compõem uma ou mais características para total reutilização, criar novas funcionalidades misturando-as na instanciação e muito mais. Scala é uma das principais linguagens em projetos de Big Data em todo o mundo, com grande uso em grandes empresas de tecnologia como o Twitter e também a linguagem principal do Spark. Bom é isso, espero que tenham gostado!

Existem algumas diferenças entre eles e vamos descobrir neste post. O parâmetro mode permite passar como valor, formas de validar Dataframes visando a qualidade dos dados. Neste post vamos criar um Dataframe utilizando PySpark e comparar as diferenças entre esses três tipos de mode, são eles: PERMISSIVE DROPMALFORMED FAILFAST Conteúdo do arquivo CSV Para este post, usaremos como exemplo um arquivo CSV contendo alguns registros variados, dentre eles, registros corrompidos. A definição de registros corrompidos para este contexto é que, para a coluna engines adicionamos alguns registros com tipos diferentes do que serão definidos no esquema. Neste caso, no esquema, a coluna engines será definida como Integer mas no conteúdo abaixo, temos alguns registro com valores do tipo String. "type","country","city","engines","first_flight","number_built" "Airbus A220","Canada","Calgary",2,2013-03-02,179 "Airbus A220","Canada","Calgary","two",2013-03-02,179 "Airbus A220","Canada","Calgary",2,2013-03-02,179 "Airbus A320","France","Lyon","two",1986-06-10,10066 "Airbus A330","France","Lyon","two",1992-01-02,1521 "Boeing 737","USA","New York","two",1967-08-03,10636 "Boeing 737","USA","New York","two",1967-08-03,10636 "Boeing 737","USA","New York",2,1967-08-03,10636 "Airbus A220","Canada","Calgary",2,2013-03-02,179 Vamos começar criando um Dataframe simples que irá carregar dados do arquivo CSV contendo os registros acima, vamos supor que o conteúdo acima seja de um arquivo chamado avioes.csv. Para modelar o conteúdo, também estamos criando um esquema que nos permitirá validar os dados. Criando um Dataframe usando o mode PERMISSIVE O mode PERMISSIVE define valores de campos como nulos quando registros corrompidos são detectados para aquela coluna. Por padrão, se você não especificar nenhum valor para o parâmetro mode, Spark definirá o valor PERMISSIVE. from pyspark.sql import SparkSession from pyspark.sql.types import StructType, StructField, StringType, IntegerType if __name__ == "__main__": spark = SparkSession.builder \ .master("local[1]") \ .appName("spark-app") \ .getOrCreate() schema = StructType([ StructField("TYPE", StringType()), StructField("COUNTRY", StringType()), StructField("CITY", StringType()), StructField("ENGINES", IntegerType()), StructField("FIRST_FLIGHT", StringType()), StructField("NUMBER_BUILT", IntegerType()) ]) read_df = spark.read \ .option("header", "true") \ .option("mode", "PERMISSIVE") \ .format("csv") \ .schema(schema) \ .load("airplanes.csv") read_df.show(10) Resultado utilizando PERMISSIVE mode Perceba que para a colune ENGINES que possui registros que não seguem o padrão de tipagem definido, foram convertidas para o valor null. Criando um Dataframe usando o mode DROPMALFORMED O mode DROPMALFORMED ignora registros corrompidos. O que significa que, se você escolher este tipo de mode, os registros corrompidos não serão listados. from pyspark.sql import SparkSession from pyspark.sql.types import StructType, StructField, StringType, IntegerType if __name__ == "__main__": spark = SparkSession.builder \ .master("local[1]") \ .appName("spark-app") \ .getOrCreate() schema = StructType([ StructField("TYPE", StringType()), StructField("COUNTRY", StringType()), StructField("CITY", StringType()), StructField("ENGINES", IntegerType()), StructField("FIRST_FLIGHT", StringType()), StructField("NUMBER_BUILT", IntegerType()) ]) read_df = spark.read \ .option("header", "true") \ .option("mode", "DROPMALFORMED") \ .format("csv") \ .schema(schema) \ .load("airplanes.csv") read_df.show(10) Resultado utilizando DROPMALFORMED mode Após definirmos o valor do mode como DROPMALFORMED, perceba que ao listar o registros do Dataframe, os registros corrompidos foram ignorados, não sendo apresentados no Dataframe. Criando um Dataframe usando o mode FAILFAST Diferente do mode DROPMALFORMED e PERMISSIVE, FAILFAST lança uma exceção quando detecta registros corrompidos. from pyspark.sql import SparkSession from pyspark.sql.types import StructType, StructField, StringType, IntegerType if __name__ == "__main__": spark = SparkSession.builder \ .master("local[1]") \ .appName("spark-app") \ .getOrCreate() schema = StructType([ StructField("TYPE", StringType()), StructField("COUNTRY", StringType()), StructField("CITY", StringType()), StructField("ENGINES", IntegerType()), StructField("FIRST_FLIGHT", StringType()), StructField("NUMBER_BUILT", IntegerType()) ]) read_df = spark.read \ .option("header", "true") \ .option("mode", "FAILFAST") \ .format("csv") \ .schema(schema) \ .load("airplanes.csv") read_df.show(10) Resultado utilizando FAILFAST mode ERROR Executor: Exception in task 0.0 in stage 0.0 (TID 0) org.apache.spark.SparkException: Malformed records are detected in record parsing. Parse Mode: FAILFAST. To process malformed records as null result, try setting the option 'mode' as 'PERMISSIVE'. Material de estudo Se quer aprender mais sobre o assunto e alcançar um alto nível de conhecimento, recomendo fortemente a leitura do(s) seguinte(s) livro(s): Spark: The Definitive Guide: Big Data Processing Made Simple (Versão Inglês) é uma referência completa para quem quer aprender o Spark e sobre as suas principais funcionalidades. Lendo esse livro, você vai aprender sobre DataFrames, Spark SQL através de exemplos práticos. O autor mergulha nas APIs de baixo nível do Spark, RDDs e também sobre como o Spark é executado em um cluster e como depurar e monitorar os aplicativos de clusters do Spark. Os exemplos práticos estão em Scala e Python. Beginning Apache Spark 3: With Dataframe, Spark SQL, Structured Streaming, and Spark Machine Library (Versão Inglês) com a nova versão do Spark, este livro explora os principais recursos do Spark, como o uso de Dataframes, Spark SQL no qual você pode usar SQL para manipular dados e Structured Streaming para processar dados em tempo real. Este livro contém exemplos práticos e trechos de código para facilitar a leitura. High Performance Spark: Best Practices for Scaling and Optimizing Apache Spark (Versão Inglês) é um livro que explora as melhores práticas usando a linguagem Spark e Scala para lidar com aplicações de dados em larga escala, técnicas para transformações utilizando RDD, e também mostra como as novas interfaces do Spark SQL melhoram o desempenho sobre a estrutura de dados RDD do SQL, exemplos de Spark MLlib e o uso de bibliotecas de aprendizado de máquina de ML e muito mais. Python Crash Course, 2nd Edition: A Hands-On, Project-Based Introduction to Programming (Versão Inglês) abrange os conceitos básicos do Python por meio de exemplos interativos e práticas recomendadas. Learning Scala: Practical Functional Programming for the Jvm (Versão Inglês) é um excelente livro que aborda a linguagem Scala através de exemplos e exercícios práticos. Lendo este livro, você aprenderá sobre os principais tipos de dados, literais, valores e variáveis. Construir classes que compõem uma ou mais características para total reutilização, criar novas funcionalidades misturando-as na instanciação e muito mais. Scala é uma das principais linguagens em projetos de Big Data em todo o mundo, com grande uso em grandes empresas de tecnologia como o Twitter e também a linguagem principal do Spark. Bom é isso, espero que tenham gostado!

Às vezes em nossos projetos temos que preencher objetos Java para testes unitários ou até mesmo criar um dump de banco de dados com dados aleatórios para testar uma característica específica e etc. Precisamos ser criativos tentando criar nomes, nomes de ruas, cidades ou documentos. Existe uma biblioteca Java interessante e útil chamada Datafaker que permite criar dados aleatórios com um grande número de provedores. Provedores são objetos baseados em um contexto, por exemplo: Se você deseja gerar dados para o objeto person, existe um provedor específico para este contexto que irá gerar nome, sobrenome e etc. Neste post vamos criar alguns exemplos usando Maven como gerenciador de dependências Java, mas a biblioteca também fornece suporte para projetos Gradle. Maven net.datafaker datafaker 1.1.0 Gerando Dados aleatórios Vamos criar uma classe Java simples que contém algumas propriedades como nome, sobrenome, endereço, gênero musical favorito e comida. public class RandomPerson { public String firstName; public String lastName; public String favoriteMusicGenre; public String favoriteFood; public String streetAddress; public String city; public String country; @Override public String toString() { return "firstName=" + firstName + "\n" + "lastName=" + lastName + "\n" + "favoriteMusicGenre="+favoriteMusicGenre + "\n" + "favoriteFood=" + favoriteFood + "\n" + "streetAddress=" + streetAddress + "\n" + "city=" + city + "\n" + "country=" + country ; } static void print(RandomPerson randomPerson){ System.out.println( randomPerson ); } } No próximo passo, vamos preencher um objeto usando os provedores que citamos na primeira seção. Primeiramente, criamos um objeto chamado randomData do tipo Faker, pois é nesta classe que contém todos os provedores no exemplo abaixo. public static void main(String[] args) { Faker randomData = new Faker(); RandomPerson randomPerson = new RandomPerson(); randomPerson.firstName = randomData.name().firstName(); randomPerson.lastName = randomData.name().lastName(); randomPerson.favoriteMusicGenre = randomData.music().genre(); randomPerson.favoriteFood = randomData.food().dish(); randomPerson.streetAddress = randomData.address().streetAddress(); randomPerson.city = randomData.address().city(); randomPerson.country = randomData.address().country(); print(randomPerson); } Após a execução, podemos ver os resultados como este no console: Resultado firstName=Dorthy lastName=Jones favoriteMusicGenre=Electronic favoriteFood=Cauliflower Penne streetAddress=7411 Darin Gateway city=Gutkowskifort country=Greece Cada execução será um novo resultado porque os provedores são aleatórios. Outra funcionalidade interessante é que podemos configurar o Locale ao instanciar um objeto. Faker randomData = new Faker(Locale.JAPANESE); Veja os resultados com base no Local.JAPANESE: Resultado firstName=航 lastName=横山 favoriteMusicGenre=Non Music favoriteFood=French Fries with Sausages streetAddress=418 美桜Square city=南斉藤区 country=Togo Material de estudo Se quer aprender mais sobre o assunto e alcançar um alto nível de conhecimento, recomendo fortemente a leitura do(s) seguinte(s) livro(s): Unit Testing Principles, Practices, and Patterns: Effective Testing Styles, Patterns, and Reliable Automation for Unit Testing, Mocking, and Integration Testing with Examples in C# (Versão Inglês) é um livro que cobre Princípios, Padrões e Práticas de Testes unitários. Ensina a projetar e escrever testes que visam áreas-chave do seu código, incluindo o modelo de domínio. Neste guia escrito de forma clara, você aprenderá a desenvolver testes e conjuntos de testes de qualidade profissional e a integrar testes em todo o ciclo de vida do aplicativo. Junit em Ação é um livro de testes popular que cobre técnicas como teste prático de seu código, usando técnicas de testes unitários e muito mais. É através da prática de testes que garantimos uma entrega de qualidade do software ao cliente final, garantindo a execução do Build e Deploy. Mastering Unit Testing Using Mockito and JUnit (Versão Inglês) é um livro que cobre as práticas do JUnit usando uma das mais famosas bibliotecas de teste chamada Mockito. Este livro ensina como criar e manter testes unitários automatizados utilizando recursos avançados do JUnit com o framework Mockito, práticas de integração contínua (famoso CI) utilizando ferramentas de mercado como Jenkins junto com um dos maiores gerenciadores de dependências em projetos Java, o Maven. Para você que está começando nesse mundo, é uma excelente escolha. Bom é isso, espero que tenham gostado!

Existem duas formas de criar tabelas no contexto Hive e neste post vamos mostrar as diferenças, vantagens e desvantagens. Tabelas Internas Para entender melhor, vamos criar uma tabela interna usando SQL no contexto Hive e falaremos sobre as suas vantagens e desvantagens. create table coffee_and_tips_table (name string, age int, address string) stored as textfile; Vantagens Tabelas internas são gerenciadas pelo Hive. Desvantagens Tabelas internas não podem acessar serviços de armazenamento remoto, por exemplo, em nuvens como Amazon AWS, Microsoft Azure e Google Cloud. Ao apagar (drop table) as tabelas internas, todos os dados, incluindo metadados e partições, serão perdidos. Tabelas externas As tabelas externas possuem recursos interessantes se comparado as tabelas internas, e é uma abordagem recomendada quando precisamos criar tabelas para nossos projetos usando Hive. No script abaixo, você pode ver a diferença entre a criação da tabela interna e a tabela externa relacionada à última seção. Acabamos de adicionar a palavra reservada external como forma de identificar uma tabela externa para a criação. create external table coffee_and_tips_external (name string, age int, address string) stored as textfile; Vantagens Os dados e metadados não serão perdidos caso a tabela seja apagada (drop table). Tabelas externas podem ser acessadas e gerenciadas por processos externos. Tabelas externas permitem acesso ao serviço de armazenamento remoto como um local de origem. Desvantagens Não seria bem uma desvantagem, mas caso seja necessário alterar o esquema ou apagar uma tabela, provavelmente será necessário executar um comando de reparação da tabela, conforme mostrado abaixo. msck repair table Dependendo do volume, esta operação pode levar algum tempo para ser concluída. Para verificar se uma tabela é interna ou externa, execute o seguinte comando abaixo e você verá na coluna table_type o resultado. hive> describe formatted Material de estudo Se quer aprender mais sobre o assunto e alcançar um alto nível de conhecimento, recomendo fortemente a leitura do(s) seguinte(s) livro(s): Programming Hive (Versão Inglês) este guia introduz você ao mundo do Apache Hive, a infraestrutura de data warehouse do Hadoop. Você aprenderá rapidamente como usar o dialeto SQL do Hive (HiveQL), consultar e analisar grandes conjuntos de dados armazenados no sistema de arquivos distribuído do Hadoop além de ensinar a como configurar um ambiente Hive. Spark: The Definitive Guide: Big Data Processing Made Simple (Versão Inglês) é uma referência completa para quem quer aprender o Spark e sobre as suas principais funcionalidades. Lendo esse livro, você vai aprender sobre DataFrames, Spark SQL através de exemplos práticos. O autor mergulha nas APIs de baixo nível do Spark, RDDs e também sobre como o Spark é executado em um cluster e como depurar e monitorar os aplicativos de clusters do Spark. Os exemplos práticos estão em Scala e Python. Beginning Apache Spark 3: With Dataframe, Spark SQL, Structured Streaming, and Spark Machine Library (Versão Inglês) com a nova versão do Spark, este livro explora os principais recursos do Spark, como o uso de Dataframes, Spark SQL no qual você pode usar SQL para manipular dados e Structured Streaming para processar dados em tempo real. Este livro contém exemplos práticos e trechos de código para facilitar a leitura. High Performance Spark: Best Practices for Scaling and Optimizing Apache Spark (Versão Inglês) é um livro que explora as melhores práticas usando a linguagem Spark e Scala para lidar com aplicações de dados em larga escala, técnicas para transformações utilizando RDD, e também mostra como as novas interfaces do Spark SQL melhoram o desempenho sobre a estrutura de dados RDD do SQL, exemplos de Spark MLlib e o uso de bibliotecas de aprendizado de máquina de ML e muito mais. Bom é isso, espero que tenham gostado!