Luísa Barros. React Native é um framework JavaScript utilizado principalmente na construção de aplicações cross-platform para dispositivos móveis. O desenvolvimento de interfaces que captam a atenção do usuário envolve muitas variáveis, e uma delas é o conjunto de estilos que irá compor essa interface.

Nesse artigo, iremos detalhar a importância de um bom gerenciamento de estilos por meio de temas, fazendo o melhor uso do TypeScript, da React Hooks e Context  API e do Styled Components.

Os temas nos permitem padronizar e reutilizar estilos em vários componentes da aplicação e nada mais são do que simples objetos onde definimos as cores, tipografia, tamanhos, espaçamentos e diversas outras propriedades que constituem a UI do nosso aplicativo. Suas possibilidades de utilização visam:

• manter a consistência da identidade de marca da aplicação;
• facilitar a implementação de funcionalidades como modo claro e escuro;
• customizar a aplicação de acordo com as preferências do usuário;
• auxiliar na acessibilidade (tamanho de fontes, correção de cores, etc);

Então, ao invés de, por exemplo, passarmos o código hexadecimal de uma cor diretamente ao componente, o passaríamos através de um tema:

O exemplo anterior pode não ter esclarecido completamente a razão para o uso de temas, uma vez que parece estar gerando código adicional para um único uso. No entanto, imagine uma situação em que estamos lidando com uma aplicação que possui uma grande quantidade de componentes e a necessidade de alterar a cor de todos os textos no sistema. Nesse cenário, em vez de modificar cada componente individualmente, podemos simplesmente ajustar o tema.

Criando os objetos de tema

Inicialmente, vamos manter toda a lógica em um único arquivo mas, conforme o projeto escale, pode ser interessante criar uma pasta específica para definir as propriedades de cada objeto de tema. Antes disso, vamos determinar a tipagem do objeto, para que cada um possua os mesmos atributos e não haja nenhuma divergência. Aqui a grande estrela entra em jogo: o TypeScript. Criaremos, então, um type chamado Theme:

Nota: As 3 propriedades abaixo são apenas um exemplo, você pode criar as suas próprias. Caso utilize alguma biblioteca com componentes já pré-definidos como o Native Base, Material UI ou React Native Paper, é importante identificar na documentação a especificação que eles seguem, e criar o seu objeto de temas no mesmo formato. Assim, você pode fazer as customizações necessárias estendendo o Default Theme da própria biblioteca ou passar diretamente o objeto com as suas propriedades.

Para garantir a liberdade de podermos adicionar quantos temas quisermos, vamos criar um único objeto, que irá conter todos os temas. Ele será do tipo Record<Theme['mode'], Theme>, com chaves e valores de um tipo específico. No exemplo abaixo, a chave será do tipo 'LIGHT' | 'DARK' e o valor será do tipo Theme, que criamos logo acima:

Com o objeto de tema criado, podemos ir para os próximos passos: gerir a funcionalidade de troca de temas e deixá-lo disponível por toda a aplicação!

Criando um hook customizado: `useTheme`

Muitas bibliotecas possuem suporte para temas, o que nos possibilita gerenciá-los de forma mais prática. Dependendo da complexidade da aplicação e do acoplamento à bibliotecas de terceiros, pode ser conveniente utilizar os recursos exportados por elas, visto que requerem mínimas configurações para implementar. Porém, iremos criar o nosso próprio hook customizado! Isso nos garante total controle da estrutura, encapsulando a lógica de gestão dos temas em um único lugar, além de não depender de nenhuma biblioteca externa.

Um hook customizado nada mais é do que uma função que utiliza as funcionalidades de estado e ciclo de vida do React, nos permitindo criar snippets de código que podem facilmente ser compartilhados entre vários componentes. Ele precisa ter o prefixo 'use' + um nome iniciando com letra maiúscula (por exemplo, useTheme). O nosso hook vai retornar uma função chamada switchTheme, que irá alterar o tema atual, e o currentTheme - um estado com o objeto do tema que está sendo utilizado no momento.

Disponibilizando o `useTheme` com a Context API

Com o hook criado, precisamos deixá-lo acessível em qualquer local da aplicação. Para isso, utilizaremos a API de contexto nativa do React, a fim de deixar o objeto de tema e a função de alteração, que são exportados pelo hook, disponíveis globalmente. Primeiro, vamos criar o contexto e utilizar o useContext() no nosso hook customizado:

Se você prestou atenção no código acima, notou que lançamos um erro caso o contexto não esteja definido, exigindo que o hook seja usando dentro de um ThemeProvider. É dessa forma que o React gerencia o acesso aos contextos, e é justamente o Provider que associa um contexto a um determinado escopo. Portanto, agora iremos exportar o nosso Provider:

Prontinho! Tudo certo para conseguirmos utilizar o nosso tema na aplicação.

Utilizando o `useTheme`  🎉

Finalmente, podemos acessar as funcionalidades fornecidas pelo nosso hook customizado em qualquer componente funcional do sistema. Para isso, precisamos apenas importá-lo e invocá-lo:

No exemplo acima, utilizamos inline styles, porém o Styled Components nos permite criar componentes customizados usando uma sintaxe muito parecida com o que é utilizado na web, o CSS-in-JS. Caso estivéssemos utilizando o Provider da própria biblioteca, poderíamos apenas estender a interface DefaultTheme dela:

Porém, uma vez que criamos nosso próprio hook, precisamos passá-lo via props. Dessa forma, conseguimos acessar o nosso tema nos arquivos de estilização e usar o Typescript a nosso favor:

Conclusão

Neste artigo, exploramos a importância dos temas em aplicativos mobile e como podem melhorar a experiência do usuário. Desenvolvemos um hook customizado que permite um controle centralizado dos estilos, priorizando código limpo e reutilizável. Disponibilizamos esse hook globalmente pela aplicação com a React Context API, a partir de um Provider, podendo ser consumido tanto pelos componentes funcionais, quanto pelos arquivos de estilização. E, por fim, podemos ver como o TypeScript desempenhou um papel fundamental para definir estruturas de dados sólidas, garantindo a coesão dos atributos e propriedades em toda a aplicação. Espero muito que com essas ferramentas, você esteja mais capaz de criar aplicativos com interfaces visualmente consistentes e altamente personalizáveis.

Referências

https://reactnavigation.org/docs/themes
https://styled-components.com/docs/advanced#theming
https://react.dev/learn/passing-data-deeply-with-context

A infraestrutura imutável é uma abordagem que visa tornar os componentes de infraestrutura inalteráveis, ou seja, que não podem ser modificados depois de implantados. Isso significa que, em vez de atualizar ou corrigir os servidores, containers ou outros recursos em execução, eles são substituídos por novas versões sempre que houver uma mudança. Neste artigo, vamos explicar o que é infraestrutura imutável, quais são os benefícios e desafios dessa abordagem e como aplicá-la em um ambiente DevOps.

O que é infraestrutura imutável?

A infraestrutura imutável é baseada no conceito de imutabilidade, que é uma propriedade de algo que não pode ser alterado ou modificado. Por exemplo, uma string é um tipo de dado imutável, pois uma vez criada, ela não pode ser modificada. Se quisermos alterar o valor de uma string, temos que criar uma nova string com o novo valor.

A infraestrutura imutável aplica esse conceito aos componentes de infraestrutura, como servidores, containers, máquinas virtuais, redes, etc. Em uma infraestrutura imutável, esses componentes são criados a partir de imagens pré-configuradas e pré-testadas, que contêm todas as dependências e configurações necessárias para executar as aplicações. Essas imagens são armazenadas em um repositório centralizado e versionado, e podem ser facilmente replicadas e distribuídas.

Uma vez implantados, esses componentes não são mais alterados manualmente ou por meio de ferramentas de gerenciamento de configuração. Eles permanecem no mesmo estado até serem descartados e substituídos por novos componentes criados a partir de novas imagens. Essa substituição ocorre sempre que há uma mudança no código da aplicação, nas configurações da infraestrutura ou nas políticas de segurança.

Quais são os benefícios da infraestrutura imutável?

A infraestrutura imutável traz diversos benefícios para o ambiente DevOps, tais como:

• Consistência: ao usar imagens pré-configuradas e pré-testadas para criar os componentes de infraestrutura, evita-se o risco de inconsistências entre os ambientes de desenvolvimento, teste e produção. Todos os componentes têm o mesmo estado e comportamento esperado, o que facilita a depuração e a resolução de problemas.
• Confiabilidade: ao eliminar as mudanças nos componentes em execução, reduz-se a possibilidade de erros humanos ou falhas nas ferramentas de gerenciamento de configuração. Além disso, ao descartar os componentes antigos e substituí-los por novos, evita-se o acúmulo de lixo ou vulnerabilidades nos sistemas operacionais ou nas aplicações.
• Segurança: ao usar imagens atualizadas e seguras para criar os componentes de infraestrutura, garante-se que eles estejam em conformidade com as políticas e normas de segurança. Além disso, ao substituir os componentes periodicamente, reduz-se a exposição a ataques ou invasões.
• Agilidade: ao automatizar o processo de criação e substituição dos componentes de infraestrutura, acelera-se o ciclo de vida das aplicações. Isso permite entregar valor aos clientes com mais rapidez e frequência, além de facilitar a integração e a entrega contínuas (CI/CD).

Quais são os desafios da infraestrutura imutável?

A infraestrutura imutável também apresenta alguns desafios que devem ser considerados antes de adotá-la, tais como:

• Custo: ao substituir os componentes de infraestrutura com frequência, pode-se aumentar o consumo de recursos computacionais e o armazenamento das imagens. Isso pode gerar um custo maior para a organização, especialmente se ela usa serviços em nuvem. Por isso, é importante planejar bem a capacidade e a escalabilidade da infraestrutura, além de monitorar e otimizar o uso dos recursos.
• Complexidade: ao usar imagens pré-configuradas e pré-testadas para criar os componentes de infraestrutura, é preciso garantir que elas estejam sempre atualizadas e compatíveis com as aplicações. Isso requer um processo rigoroso de controle de versão, teste e validação das imagens, além de uma boa comunicação entre as equipes de desenvolvimento e operações. Além disso, é preciso definir uma estratégia de backup e recuperação dos dados, pois os componentes são descartados com frequência.
• Cultura: ao adotar a infraestrutura imutável, é preciso mudar a mentalidade e os hábitos das equipes de desenvolvimento e operações, que estão acostumadas a modificar os componentes em execução. Isso requer uma cultura de colaboração, automação e aprendizado contínuo, além de uma visão compartilhada dos objetivos e benefícios da infraestrutura imutável.

Como aplicar o princípio da infraestrutura imutável em um ambiente DevOps?

Para aplicar o princípio da infraestrutura imutável em um ambiente DevOps, é preciso seguir alguns passos, que podem variar de acordo com as características e necessidades de cada organização. A seguir, apresentamos um exemplo genérico de como aplicar a infraestrutura imutável em um ambiente DevOps:

• Definir as imagens: o primeiro passo é definir as imagens que serão usadas para criar os componentes de infraestrutura. As imagens devem conter todas as dependências e configurações necessárias para executar as aplicações, como o sistema operacional, os pacotes, os drivers, os scripts, etc. As imagens podem ser criadas manualmente ou por meio de ferramentas de automação, como o Packer1.
• Armazenar as imagens: o segundo passo é armazenar as imagens em um repositório centralizado e versionado, que permita o acesso e a distribuição das imagens pelas equipes de desenvolvimento e operações. O repositório deve ter mecanismos de segurança, como autenticação, criptografia e assinatura digital. O repositório pode ser local ou em nuvem, como o Amazon Elastic Container Registry (ECR)2 ou o Azure Container Registry (ACR)3.
• Testar as imagens: o terceiro passo é testar as imagens antes de implantá-las na infraestrutura. Os testes devem verificar se as imagens estão funcionando corretamente e se estão em conformidade com os requisitos funcionais e não funcionais das aplicações. Os testes podem ser realizados manualmente ou por meio de ferramentas de automação, como o Testinfra4 ou o Serverspec5.
• Implantar as imagens: o quarto passo é implantar as imagens na infraestrutura, criando os componentes correspondentes, como servidores, containers ou máquinas virtuais. A implantação deve ser feita por meio de ferramentas de automação, que permitem provisionar, configurar e gerenciar os componentes de forma rápida e consistente. Algumas ferramentas que podem ser usadas são o Terraform6, o Ansible7 ou o Chef8.
• Substituir os componentes: o quinto passo é substituir os componentes sempre que houver uma mudança nas aplicações ou nas configurações da infraestrutura. A substituição deve ser feita por meio de ferramentas de automação, que permitem criar novos componentes a partir das novas imagens e descartar os componentes antigos sem interromper o serviço. Algumas ferramentas que podem ser usadas são o Kubernetes, o Docker Swarm ou o Amazon Elastic Container Service (ECS).

Para aplicar o princípio da infraestrutura imutável em um ambiente DevOps, você pode seguir os seguintes passos:

• Criar uma imagem do seu aplicativo que contenha todas as dependências e configurações necessárias para executá-lo. Você pode usar ferramentas como o Docker1 ou o Packer2 para criar imagens de containers ou de máquinas virtuais, respectivamente.
• Armazenar a imagem do seu aplicativo em um repositório centralizado e versionado, que permita o acesso e a distribuição das imagens pelas equipes de desenvolvimento e operações. Você pode usar serviços em nuvem como o Amazon Elastic Container Registry (ECR)3 ou o Azure Container Registry (ACR)4 para armazenar imagens de containers, por exemplo.
• Testar a imagem do seu aplicativo antes de implantá-la na infraestrutura. Você pode usar ferramentas como o Testinfra ou o Serverspec para escrever e executar testes de infraestrutura usando Python ou Ruby, respectivamente.
• Implantar a imagem do seu aplicativo na infraestrutura, criando os componentes correspondentes, como servidores, containers ou máquinas virtuais. Você pode usar ferramentas como o Terraform, o Ansible ou o Chef para provisionar, configurar e gerenciar a infraestrutura como código.
• Substituir os componentes da infraestrutura sempre que houver uma mudança no seu aplicativo ou nas configurações da infraestrutura. Você pode usar ferramentas como o Kubernetes, o Docker Swarm ou o Amazon Elastic Container Service (ECS) para criar e gerenciar clusters de containers que podem ser substituídos facilmente.

Um exemplo simples de infraestrutura imutável é usar uma imagem do Linux que já contém o Apache instalado e configurado para servir uma página web estática. Neste caso, você não precisa modificar o servidor depois de criá-lo, apenas substituí-lo por uma nova imagem quando precisar atualizar o Apache ou o Linux. Um exemplo de código que usa o Docker e o Terraform para criar e gerenciar essa infraestrutura imutável é o seguinte:

O código usa o Docker para criar uma imagem com o Apache e uma página web estática, e o Terraform para criar uma instância EC2 que executa um container com essa imagem e expõe a porta 80. Para acessar a página web, basta usar o endereço IP da instância.

Conclusão

Neste artigo, vimos como aplicar o princípio da infraestrutura imutável em um ambiente DevOps. Aprendemos o que é infraestrutura imutável, quais são os benefícios e desafios dessa abordagem e como aplicá-la em um ambiente DevOps. Vimos também alguns exemplos de ferramentas que podem nos auxiliar nesse processo.

A infraestrutura imutável é uma abordagem que visa aumentar a consistência, a confiabilidade, a segurança e a agilidade da infraestrutura, evitando as mudanças nos componentes em execução e substituindo-os por novas versões sempre que houver uma alteração. Para aplicar essa abordagem em um ambiente DevOps, é preciso usar ferramentas de automação que permitam criar, armazenar, testar e implantar imagens pré-configuradas e pré-testadas dos componentes de infraestrutura. Assim, é possível entregar valor aos clientes com mais rapidez e qualidade, além de facilitar a integração e a entrega contínuas (CI/CD).

Referências Bibliográficas

• Docker Documentation - https://docs.docker.com/
• Packer Documentation - https://www.packer.io/docs
• Amazon Elastic Container Registry (ECR) - https://aws.amazon.com/ecr/
• Azure Container Registry (ACR) - https://azure.microsoft.com/en-us/services/container-registry/
• Testinfra Documentation - https://testinfra.readthedocs.io/en/latest/
• Serverspec Documentation - https://serverspec.org/
• Terraform Documentation - https://www.terraform.io/docs/index.html
• Ansible Documentation - https://docs.ansible.com/ansible/latest/index.html
• Chef Documentation - https://docs.chef.io/

Raimundo Neto Barros. Redes Neurais Convolucionais (CNNs), também conhecidas como ConvNets ou Convolutional Neural Networks, são um tipo de arquitetura de rede neural projetada especialmente para tarefas de processamento de imagens e reconhecimento de padrões. As CNNs têm sido uma parte essencial do avanço da inteligência artificial em campos como visão computacional, reconhecimento de imagem e processamento de vídeo.

Este resumo detalhado irá explorar os principais aspectos das CNNs.

Arquitetura de Camadas

As CNNs são compostas por camadas interconectadas, com três tipos principais de camadas: Camadas de Convolução, Camadas de Pooling (Agrupamento) e Camadas Fully Connected (Totalmente Conectadas).

Camadas de Convolução

• As camadas de convolução são o componente fundamental das CNNs. Eles consistem em filtros ou grãos, que são matrizes de pesos pequenos que percorrem a imagem de entrada em pequenos passos, realizando operações de convolução para detectar características relevantes. Essas características incluem bordas, texturas, padrões e outras informações importantes.

Camadas de Pooling

• As camadas de pooling (ou agrupamento) são utilizadas para reduzir a dimensionalidade dos dados, mantendo as características mais importantes. O pooling geralmente envolve uma seleção do valor máximo (Max Pooling) ou médio (Average Pooling) em uma região local da imagem convolucional.

Camadas Totalmente Conectadas

• As camadas totalmente conectadas são semelhantes às camadas tradicionais de redes neurais artificiais. Eles são responsáveis ​​por tomar as características extraídas pelas camadas anteriores e utilizá-las para realizar a classificação ou a regressão de saída.

Funções de Ativação

• As CNNs utilizam funções de ativação, como a função ReLU (Rectified Linear Unit), para introduzir não-linearidade nas camadas convolucionais e melhorar a capacidade de aprendizado da rede.

Camadas de Normalização

• Camadas de normalização, como a Normalização em lote, são usadas para acelerar o treinamento e melhorar a estabilidade da rede.

Aprendizado de Características Hierárquicas

Uma das principais vantagens das CNNs é sua capacidade de aprender características hierarquicamente complexas. Camadas iniciais detectam características simples, como bordas, enquanto camadas mais profundas identificam características cada vez mais abstratas, como objetos inteiros.

Treinamento com Backpropagation

• As CNNs são treinadas usando o algoritmo de retropropagação (backpropagation), ajustando os pesos das redes para minimizar uma função de perda. O aprendizado geralmente envolve grandes conjuntos de dados rotulados.

Transferência de aprendizagem

• As CNNs pré-treinadas em grandes conjuntos de dados, como o ImageNet, podem ser adaptadas para tarefas específicas com menores conjuntos de dados através da técnica de transferência de aprendizagem. Isso permite a reutilização de recursos aprendidos anteriormente.

Aplicações

• As CNNs têm uma ampla gama de aplicações, incluindo reconhecimento de imagem, classificação de objetos, segmentação de imagens, reconhecimento de texto em imagens, detecção de rostos, diagnóstico médico baseado em imagens, entre outros.

As Redes Neurais Convolucionais têm revolucionado a visão computacional e são essenciais para uma série de aplicações práticas, tornando possível a automação de tarefas anteriormente complexas em domínios que envolvem imagens e visão por computador. Elas continuam sendo uma área de pesquisa ativa, com avanços constantes e adaptações para diversos campos.

O reconhecimento de dígitos escritos à mão é uma tarefa fundamental em aprendizado de máquina e visão computacional. Neste tutorial, você aprenderá a criar um modelo de reconhecimento de dígitos manuscritos usando TensorFlow, uma das bibliotecas mais populares para aprendizado profundo e redes neurais. Este tutorial é direcionado a desenvolvedores e entusiastas que desejam explorar o mundo do reconhecimento de padrões por meio de redes neurais.

TensorFlow

TensorFlow é uma biblioteca de código aberto poderosa e popular para aprendizado de máquina e inteligência artificial. Desenvolvida pelo Google Brain, é uma ferramenta extremamente flexível que oferece uma ampla gama de funcionalidades para desenvolver e treinar modelos complexos de aprendizado profundo.

Vamos explorar detalhadamente as principais características e conceitos do TensorFlow:

Modelagem com Grafos Computacionais: TensorFlow representa as operações matemáticas em forma de grafos direcionados, onde nós representamos operações e as arestas representam os dados (tensores) que fluem entre essas operações. Isso permite uma otimização eficiente e paralelização das operações.

O TensorFlow é centrado no conceito de tensores, que são estruturas de dados multidimensionais. Os tensores são de várias dimensões (0D a ND) e podem ser a unidade básica para representar os dados de entrada, saída e as configurações dos modelos.

Flexibilidade de Construção de Modelos: O TensorFlow oferece dois estilos principais para construção de modelos: o modo imperativo (usando APIs como Keras) e o modo declarativo (usando uma API do TensorFlow). Isso permite a construção de modelos de forma intuitiva e flexível. Keras API: Integrada ao TensorFlow, a API Keras é uma interface de alto nível que facilita a criação, treinamento e avaliação de modelos. Keras é conhecida por sua simplicidade e eficiência.

Treinamento Distribuído: O TensorFlow suporta treinamento distribuído, permitindo que modelos sejam treinados simultaneamente em vários dispositivos, como GPUs e TPUs, melhorar a escalabilidade e a eficiência do treinamento.

Finalidades e aplicações práticas

Um Modelo de Reconhecimento de Dígitos Manuscritos com TensorFlow tem a finalidade de confidencialidade e classificação de dígitos escritos à mão em imagens ou documentos. Esse tipo de modelo tem várias aplicações práticas, incluindo:

Reconhecimento de Dígitos em Cheques e Documentos Financeiros: as instituições financeiras utilizam modelos de reconhecimento de dígitos para processar cheques e documentos que contêm números escritos à mão, agilizando o processo de verificação e eliminação de erros.

Automatização de Processos Empresariais: as empresas podem utilizar modelos de reconhecimento de dígitos para automatizar a leitura de formulários, faturas, cheques e outros documentos, economizando tempo e reduzindo erros de interpretação humana.

Sistemas de Pagamento Automático: em sistemas financeiros, o reconhecimento de dígitos é usado para automatizar a leitura de cheques, códigos de barras em boletos e outras formas de pagamento, agilizando o processamento.

Sistemas de Reconhecimento de Escrita Manual: pode ser usado como componente em sistemas de reconhecimento de escrita manual mais complexos, onde o reconhecimento de dígitos é a primeira etapa para a identificação de palavras ou frases escritas à mão.

Aplicativos Móveis: aplicativos móveis podem integrar modelos de reconhecimento de dígitos para facilitar a entrada de dados, como reconhecimento de números de telefone ou códigos de autenticação.

O desenvolvimento de aplicações educacionais: utilizando um Modelo de Reconhecimento de Dígitos Manuscritos com TensorFlow pode ser uma maneira eficaz de ajudar os alunos a aprenderem a escrever e considerar números de forma interativa e envolvente.

Pré-requisitos

Antes de começarmos, você precisará atender aos seguintes requisitos para execução dos códigos:

Conhecimento em Python: Este tutorial pressupõe que você tenha conhecimento básico na linguagem Python, incluindo manipulação de arrays da biblioteca NumPy.

Instalação do TensorFlow: Certifique-se de que o TensorFlow esteja instalado no seu ambiente Python. Você pode instalá-lo usando o comando pip:

Agora, vamos criar um modelo de reconhecimento de dígitos com o passo a passo a seguir.

Passo 1: Conjunto de Dados MNIST

O conjunto de dados MNIST é um conjunto clássico para tarefas de reconhecimento de dígitos manuscritos. Ele consiste em 60.000 imagens de treinamento e 10.000 imagens de teste, cada uma representando um único dígito de 0 a 9. Começaremos carregando esse conjunto de dados utilizando o seguinte código.

Passo 2: Pré-processamento dos Dados

O pré-processamento dos dados é uma etapa extremamente importante no treinamento de redes neurais, pois essa etapa interfere diretamente nos resultados dos algoritmos. Primeiro, normalizamos as imagens para que os valores dos pixels estejam no intervalo de 0 a 1.

Passo 3: Construindo o Modelo

Agora, construiremos o modelo de rede neural. Neste exemplo, usaremos uma rede neural convolucional (CNN) simples, conhecida por seu desempenho em tarefas de visão computacional.

Passo 4: Compilando o Modelo

Após construir o modelo, é hora de compila-lo. Definiremos a função de perda, o otimizador e as métricas para monitorar durante o treinamento do algoritmo.

Passo 5: Treinamento do Modelo

Agora, treinaremos o modelo usando os dados de treinamento da base MNIST.

Passo 6: Avaliação do Modelo

Após o treinamento, avaliaremos o desempenho do modelo utilizando os dados de teste. Vale ressaltar, que os dados de teste são diferentes dos dados de treino.

Resultados

Após seguir os passos anteriores para rodar sua rede neural, você deve obter bons resultados se tratando do desempenho do algoritmo na classificação das imagens. Caso deseje ver melhor a classificação dos dados você pode plotar o resultado utilizando a biblioteca do Python chamada Matplotlib. Para plotar os resultados siga os passos a seguir.

Passo 1: importe a biblioteca

Passo 2: Escolha uma das imagens aleatoriamente

Passo 3: Realize a previsão do modelo

Passo 4: Obtenha a classe de previsão

Passo 5: Plotando os resultados

Após plotado o resultado, será mostrado uma imagem aleatória, com uma das imagens da base, com uma legenda na imagem: Classe Real e Classe Prevista, na imagem você pode verificar o acerto do algoritmo.

Conclusão

Neste tutorial, você aprendeu como criar um modelo de reconhecimento de dígitos escritos à mão usando TensorFlow. Começamos carregando o conjunto de dados MNIST, realizamos o pré-processamento das imagens, construímos um modelo de rede neural convolucional (CNN), o compilamos, treinamos e avaliamos seu desempenho e plotamos um resultado aleatório da classificação dos dados. O modelo atingiu uma alta precisão na classificação de dígitos manuscritos.

Agora você possui as habilidades necessárias para começar a explorar tarefas mais complexas de aprendizado profundo e visão computacional. Lembre-se de que o aprendizado de máquina é uma disciplina vasta e em constante evolução, com aplicações emocionantes em diversas áreas.

Bibliografia

JURASZEK, Guilherme Defreitas et al. Reconhecimento de produtos por imagem utilizando palavras visuais e redes neurais convolucionais. 2014.

TensorFlow. https://www.tensorflow.org/

Conjunto de Dados MNIST. http://yann.lecun.com/exdb/mnist/

TensorFlow Tutorials. https://www.tensorflow.org/tutorials

Caro leitor ávido por explorar as profundezas do Google Cloud Platform até agora exploramos apenas os fundamentos dessa plataforma poderosa. No entanto, chegou a hora de subir um degrau e mergulhar no mundo avançado do GCP. Este é o terceiro e último capítulo de nossa série, onde vamos desvendar as capacidades mais sofisticadas e as funcionalidades avançadas dessa incrível plataforma em nuvem.

Aqui é onde começa os poderes da ferramenta Google Cloud Platform?

Se você está aqui, é porque já dominou as noções básicas e está pronto para ir além, explorando recursos que podem impulsionar sua eficiência, segurança e escalabilidade. Neste guia avançado, você descobrirá como aproveitar ao máximo o Google Cloud Platform, aproveitando suas ferramentas e serviços de alto nível para resolver problemas complexos e alcançar objetivos ambiciosos.

Ao longo deste artigo, vamos explorar tópicos como Segurança e Conformidade Avançada, Alta Disponibilidade e Recuperação de Desastres, Integração com Firebase com Serviços Avançados e muito mais. Prepare-se para mergulhar no nível avançado da nuvem e expandir suas habilidades de computação em nuvem para um novo patamar.

Seja bem-vindo à última parte de nossa série sobre o Google Cloud Platform, onde a jornada se torna ainda mais emocionante e desafiadora. Vamos juntos explorar o potencial ilimitado dessa plataforma e dominar suas ferramentas avançadas. Estamos prestes a abrir portas para um mundo de oportunidades, então, vamos começar!

Dito isso, vamos avançar para a etapa final deste mundo emocionante de Google Cloud Platform!

Segurança e Conformidade Avançada no Google Cloud Platform (GCP)

Em um ambiente de computação em nuvem, a segurança é fundamental. À medida que migramos nossas aplicações e dados críticos para o Google Cloud Platform (GCP), é imperativo fortalecer a segurança da infraestrutura para proteger contra ameaças cada vez mais sofisticadas. Neste guia, exploraremos como você pode elevar a segurança da sua infraestrutura no GCP a um nível avançado, abrangendo políticas de IAM (Identity and Access Management), auditorias e monitoramento.

1. Políticas de IAM Avançadas:

O IAM é a base da segurança no GCP, permitindo que você controle o acesso de usuários e recursos. No nível avançado, você pode criar políticas de IAM detalhadas e personalizadas para garantir que apenas as pessoas certas tenham acesso aos recursos certos. Isso inclui a implementação de políticas de least privilege, que concedem o mínimo de privilégios necessários para cada função, a seguir um exemplo de código, vejamos:

2. Regras de Auditoria e Trilha de Auditoria:

A auditoria desempenha um papel crítico na segurança. No GCP, você pode configurar regras de auditoria avançadas para registrar atividades suspeitas ou de alto risco. Isso permite que você rastreie quem acessou seus recursos, quando o fizeram e quais ações foram executadas. Você pode definir alertas para atividades incomuns e tomar medidas imediatas, a seguir um exemplo de código, vejamos:

3. Monitoramento Avançado:

O monitoramento constante é essencial para identificar ameaças em tempo real. Utilize as ferramentas de monitoramento avançado do GCP, como o Cloud Monitoring e o Cloud Logging, para coletar e analisar dados de log e métricas. Configure alertas personalizados para detectar anomalias, ataques ou atividades não autorizadas, a seguir um exemplo de código, vejamos:

4. Gerenciamento de Chaves Criptográficas:

Para proteger seus dados, é crucial gerenciar chaves criptográficas de forma eficaz. O GCP oferece serviços avançados de gerenciamento de chaves, como o Cloud Key Management Service (KMS), que permite criar, gerenciar e girar chaves de criptografia de maneira segura.

5. Controle de Identidade Federada:

Em cenários complexos, onde a autenticação é necessária em vários sistemas, o GCP suporta controle de identidade federada. Isso permite que você integre seu sistema de identidade existente com o GCP, simplificando o acesso e melhorando a segurança.

6. Conformidade e Certificações:

O GCP está em conformidade com várias normas de segurança, como SOC 2, ISO 27001 e HIPAA. No nível avançado, você pode utilizar essas certificações para garantir a conformidade regulatória em sua organização e configurar políticas de conformidade personalizadas.

7. Proteção de Dados Sensíveis:

Identifique e classifique dados sensíveis em seu ambiente GCP. Implemente políticas de proteção de dados avançadas, como o uso de criptografia e mascaramento de dados, para garantir que informações confidenciais permaneçam seguras.

8. Testes de Intrusão e Simulações de Ataques:

Para garantir que sua infraestrutura seja resistente a ataques, realize testes de intrusão e simulações de ataques de penetração. Isso ajudará a identificar vulnerabilidades e aprimorar as medidas de segurança.

9. Autenticação Multifatorial (MFA):

Implemente a autenticação multifatorial em todas as contas críticas. Isso adiciona uma camada extra de segurança, exigindo que os usuários forneçam múltiplos fatores de autenticação para acessar recursos.

10. Resposta a Incidentes:

Desenvolva um plano de resposta a incidentes detalhado. No nível avançado, você pode automatizar a detecção de incidentes e a resposta a eles, garantindo uma reação rápida a ameaças.

Fortalecer a segurança e garantir a conformidade avançada no Google Cloud Platform é uma jornada contínua. À medida que novas ameaças surgem e a infraestrutura evolui, é essencial estar atualizado e adotar as melhores práticas de segurança. Este guia fornece uma base sólida para começar a proteger sua infraestrutura no GCP em um nível avançado.

Estes são apenas exemplos simples para ilustrar os conceitos. Na prática, a configuração de políticas de IAM, regras de auditoria, monitoramento e outras práticas avançadas de segurança no GCP pode envolver configurações mais detalhadas e complexas, dependendo das necessidades específicas do seu projeto.

Alta Disponibilidade e Recuperação de Desastres: Protegendo suas Aplicações no Google Cloud Platform

A alta disponibilidade (HA) e a recuperação de desastres (DR) são componentes críticos da estratégia de segurança e continuidade de negócios em qualquer ambiente de nuvem, incluindo o Google Cloud Platform (GCP). Garantir que suas aplicações e serviços estejam sempre disponíveis e prontos para lidar com eventos adversos é essencial para atender às expectativas dos clientes e mitigar os riscos associados a interrupções não planejadas.

1. Alta Disponibilidade no GCP:

Alta disponibilidade refere-se à capacidade de manter seus sistemas em funcionamento sem interrupções significativas, mesmo quando ocorrem falhas. O GCP oferece várias ferramentas e recursos para ajudar a alcançar esse objetivo:

• Balanceamento de Carga: Utilize o balanceamento de carga do GCP para distribuir o tráfego entre várias instâncias, zonas ou regiões, garantindo que a carga seja distribuída de maneira uniforme e que os serviços permaneçam acessíveis, mesmo em caso de falha em uma instância, vejamos o exemplo de código:

• Zonas e Regiões Múltiplas: Distribua seus recursos em diferentes zonas e regiões para evitar que uma única falha afete todo o seu sistema. O GCP oferece redundância geográfica para melhorar a disponibilidade.
  
• Instâncias de Máquinas Virtuais (VMs) Replicadas: Implemente instâncias VM replicadas em várias zonas ou regiões. Se uma instância falhar, o tráfego é automaticamente redirecionado para as instâncias em funcionamento.
  
• Serviços Gerenciados: Use serviços gerenciados do GCP, como o Google Kubernetes Engine (GKE) e o App Engine, que lidam automaticamente com tarefas de escalabilidade e recuperação de falhas.

2. Recuperação de Desastres no GCP:

Além de garantir a alta disponibilidade, é crucial ter planos de recuperação de desastres eficazes para lidar com eventos graves que possam causar interrupções prolongadas. O GCP oferece recursos e práticas recomendadas para implementar uma estratégia de recuperação de desastres sólida:

• Cópias de Segurança (Backups) e Snapshots: Faça cópias de segurança regulares de seus dados e crie snapshots de suas VMs. Isso permite restaurar rapidamente os sistemas em caso de falha, vejamos o exemplo de código:

• Replicação de Dados: Utilize serviços como o Cloud Storage para replicar seus dados em locais geograficamente dispersos, garantindo a redundância de dados.
  
• Planos de Continuidade de Negócios (BCP) e Recuperação de Desastres (DRP): Desenvolva planos abrangentes de BCP e DRP que definam os procedimentos a serem seguidos em caso de desastre. Teste regularmente esses planos para garantir sua eficácia.
  
• Backup e Replicação de Bancos de Dados: Para bancos de dados críticos, implemente estratégias de backup e replicação para garantir a disponibilidade dos dados em caso de falha.
  
• Failover Automatizado: Configure sistemas de failover automatizado para redirecionar o tráfego para recursos de backup ou de recuperação em caso de falha.
  
• Testes de Recuperação de Desastres: Realize testes periódicos de recuperação de desastres para avaliar a prontidão de sua infraestrutura e equipe em situações de crise.

Garantir a alta disponibilidade e a recuperação de desastres no GCP é um esforço contínuo que exige planejamento cuidadoso e implementação diligente. Ao adotar as melhores práticas e usar os recursos disponíveis no GCP, você pode proteger suas aplicações e dados contra interrupções indesejadas e manter a continuidade dos negócios, independentemente dos desafios que possam surgir. A segurança e a resiliência devem ser prioridades fundamentais em sua jornada na nuvem.

Integração com Firebase: Expandindo o Google Cloud com Serviços Avançados

O Firebase, uma plataforma de desenvolvimento de aplicativos móveis e web, é conhecido por sua simplicidade e eficácia na criação de aplicativos de alta qualidade. No entanto, quando se trata de estender seu aplicativo para um nível mais avançado, o Google Cloud Platform (GCP) é uma escolha natural. A boa notícia é que você pode integrar o Firebase com o GCP para aproveitar os serviços avançados da nuvem e expandir significativamente a funcionalidade de seus aplicativos. Neste guia, exploraremos como realizar essa integração de maneira eficaz.

Antes de mais nada, certifique-se de consultar a documentação oficial do Firebase e do GCP para obter informações detalhadas sobre como realizar essas integrações.

1. Configurando a Integração Inicial:

A primeira etapa para estender seu aplicativo Firebase com os serviços avançados do GCP é configurar a integração. Certifique-se de que sua conta Firebase e conta GCP estejam vinculadas e que você tenha permissões adequadas em ambas as contas. Isso permitirá que você acesse recursos do GCP, como Cloud Functions e Cloud Storage, diretamente do Firebase, vejamos o exemplo de código:

2. Usando o Cloud Functions:

Uma das maneiras mais poderosas de estender seu aplicativo Firebase é por meio das Cloud Functions. Essas funções permitem que você execute código do lado do servidor em resposta a eventos específicos, como acionadores de banco de dados ou eventos de autenticação. Você pode aproveitar isso para processar dados, automatizar tarefas ou executar lógica avançada no GCP, vejamos o exemplo de código:

3. Armazenamento Avançado com o Cloud Storage:

Enquanto o Firebase oferece armazenamento em nuvem para arquivos, o Cloud Storage do GCP fornece recursos avançados de armazenamento, incluindo classes de armazenamento, controle de acesso refinado e a capacidade de gerenciar grandes volumes de dados de maneira eficiente, vejamos o exemplo de código:

4. Bancos de Dados Escaláveis:

O Firebase Realtime Database é excelente para aplicativos em tempo real, mas para casos de uso mais avançados, como análise de dados em grande escala, o BigQuery do GCP é uma escolha ideal. Você pode integrar o BigQuery ao Firebase para executar consultas complexas em seus dados e obter insights valiosos.

5. Autenticação e Autorização Avançadas:

O Firebase oferece recursos de autenticação robustos, mas o GCP complementa isso com políticas de autenticação e autorização avançadas usando o Identity and Access Management (IAM). Você pode controlar o acesso granularmente e definir permissões específicas para recursos no GCP.

6. Análise de Dados e Machine Learning:

O GCP oferece uma gama de serviços avançados de análise de dados e machine learning, como o BigQuery ML e o AI Platform. Integrando esses serviços ao Firebase, você pode criar modelos de machine learning personalizados e obter insights mais profundos sobre o comportamento dos usuários.

7. Escalabilidade e Confiabilidade:

À medida que seus aplicativos crescem, a escalabilidade e confiabilidade se tornam críticas. O GCP oferece opções de escalabilidade elástica e ferramentas avançadas de monitoramento e diagnóstico para garantir que seus aplicativos permaneçam disponíveis e com desempenho otimizado.

8. Monitoramento e Depuração:

Utilize as ferramentas de monitoramento e depuração avançadas do GCP para rastrear o desempenho de seus aplicativos Firebase e solucionar problemas de maneira eficaz. O Stackdriver fornece insights valiosos sobre o funcionamento de seus serviços em nuvem.

Ao dominar essa integração, você estará bem posicionado para desenvolver aplicativos de alto desempenho e oferecer experiências excepcionais aos usuários. Portanto, comece a explorar as possibilidades e aproveite ao máximo essa combinação poderosa.

Integrar o Firebase com o Google Cloud Platform permite que você aproveite o melhor de ambos os mundos: a simplicidade do Firebase e os recursos avançados do GCP. Isso possibilita a criação de aplicativos mais robustos e escaláveis, atendendo às demandas de crescimento e complexidade.

Chegamos ao nosso destino final nesta incrível jornada pelo Google Cloud Platform. Este artigo marca o capítulo final de nossa série de três partes, onde exploramos as complexidades e desafios avançados dessa plataforma de nuvem poderosa. Ao longo dessa jornada, você aprendeu a orquestrar contêineres com precisão, implementar estratégias avançadas de gerenciamento de dados e até mesmo a integrar o Firebase para expandir seus horizontes de desenvolvimento.

É com grande entusiasmo que encerramos esta série, sabendo que você agora possui um conhecimento sólido e está preparado para se aventurar em território avançado. No entanto, lembre-se de que a jornada de aprendizado na nuvem é contínua. À medida que a tecnologia evolui e novos desafios surgem, estar atualizado é essencial. Continue explorando, experimentando e expandindo suas habilidades. O GCP oferece um vasto horizonte de oportunidades, e agora você está preparado para explorá-lo plenamente.

Aqui encerro este último capítulo da série sobre o Google Cloud Platform. Agora, gostaríamos muito de ouvir a sua opinião. Como têm sido suas experiências com nossos guias recentes sobre o Google Cloud Platform? Ficaríamos gratos se compartilhasse seus pensamentos e comentários conosco na seção de comentários deste artigo.- Gabriel Reis Duarte.

Desde que comecei a estudar Machine Learning pensei em como iria disponibilizar o modelo de classificação que treinei para que seja acessado por usuários ou aplicações. A principal barreira que me deparei foi o fato de que a aplicação web que faria uso do modelo de classificação não era feita em Python, com isso não foi possível simplesmente chamar o classificador em uma controller ou service.

Nesses casos, a solução foi a criação de uma API que servisse apenas ao propósito de receber uma requisição com os atributos de um novo exemplar e retornar o resultado gerado pelo classificador. Como o propósito da API é muito simples, busquei um framework que atendesse apenas a este propósito e com isso me deparei com o Flask.

Flask

O Flask é um micro-framework escrito em Python que simplifica o desenvolvimento de APIs, permitindo iniciar um projeto de forma simples e ir evoluindo à medida que forem aparecendo novas necessidades, como a adição de um ORM, caso seja necessário persistir informações em um banco de dados.

Criação e persistência de um modelo pré treinado

Iniciaremos pela implementação do modelo de classificação e como o foco do artigo é a disponibilização do modelo, não darei tanta ênfase a parte de Machine learning. Primeiro devemos criar um novo diretório para nosso projeto, recomendo a utilização do virtualenv para isolar a instalação das bibliotecas e do Python que iremos utilizar.

Com o projeto criado, devemos inicializar o repositório git para que os arquivos sejam versionados através da execução do comando git init dentro do diretório do projeto. Com o repositório git criado, iremos alterar o arquivo .gitignore para que os arquivos gerados pelo virtualenv sejam ignorados.

Como iremos utilizar a base de dados IRIS, que é uma base de dados utilizada largamente na avaliação de modelos de classificação, a forma mais simples de carregá-la é através da biblioteca scikit-learn. A outra biblioteca utilizada será o tensorflow-cpu, que é uma biblioteca utilizada em projetos de Deep learning, porém iremos utilizar uma API de alto nível chamada keras que simplifica o desenvolvimento de redes neurais.

Antes de continuarmos, vale à pena esclarecer o motivo de estarmos trabalhando com o tensorflow-cpu e não com o tensorflow. Primeiramente, a ausência de GPU e das instalações necessárias para que o tensorflow seja executado através da GPU, e em segundo lugar, o tamanho máximo permitido pelo Heroku para uma aplicação após instalação de suas dependências e compactação, que no momento da escrita deste artigo é de 500MB e apenas a biblioteca tensorflow possui aproximadamente 600MB. Contudo, é possível utilizar o tensorflow durante o desenvolvimento do modelo fazendo uso de GPU durante as etapas de treino e teste, e uma vez finalizado, utilizar o tensorflow-cpu em produção.

Após executar o comando pip install scikit-learn tensorflow-cpu para instalar as bibliotecas utilizadas, iremos criar um novo arquivo chamado classifier.py e nele iremos treinar e salvar nosso modelo de classificação.

O código abaixo define uma rede neural contendo duas camadas ocultas com 128 e 64 neurônios, respectivamente. Ambas as camadas aplicam a função de ativação ReLu e têm os valores dos pesos inicializados utilizando a técnica RandomNormal que está fixada com um SEED para que o resultado seja reproduzível. Uma vez que a base IRIS contém três classes, a ultima camada possui três neurônios e utiliza a função de ativação softmax.

Após feita a compilação e o treinamento da rede neural, atingiu-se uma acurácia de 0.966 no grupo separado para teste, o que é o suficiente para o objetivo deste artigo. Com isso, ao final do script salvamos um arquivo chamado model.h5 que contém nosso modelo treinado. Existem outras métricas e arquiteturas que podem ser testadas e podem gerar resultados melhores, porém nosso foco é a disponibilização de um modelo já treinado e não encontrar o melhor modelo de classificação.

API Flask

Com nosso modelo treinado, chegou a hora de criarmos uma API para disponibilizá-lo. Como dito anteriormente, iremos utilizar o micro-framework Flask para criação da API, assim o primeiro passo é instalar o Flask executando o comando pip install flask.

Uma vez instalado, será criado um arquivo chamado main.py, contendo o código a seguir. Neste código é declarada a rota /predict que responde ao método HTTP POST, e ao receber uma lista de atributos de um exemplar da base IRIS, retorna uma lista contendo a probabilidade para cada uma das classes possíveis.

Como descrito nos comentários do código, seguem alguns pontos importantes:

• o modelo é carregado antes de inicializar a aplicação, uma vez que este processo é custoso e fazê-lo durante cada requisição aumentaria consideravelmente o tempo de resposta da API;
• o resultado do método keras.Sequential.predict() deve ser convertido para um objeto do tipo lista, uma vez que a função jsonify não consegue serializar objetos numpy.

A aplicação é iniciada a partir da execução do comando python main.py, e fica disponível em localhost:5000. Para testar a API, basta fazer uma request executando a chamada cURL a seguir ou através de aplicações como Postman ou Insomina.

Deploy Heroku

Com a conclusão da API, chegou o momento do deploy que será feito na plataforma Heroku. O Heroku é uma Platform as a Service (PaaS) que disponibiliza um ambiente cloud utilizado para o provisionamento de aplicações web. Devido a simplicidade e baixa necessidade de configurações, é uma boa escolha para quem busca disponibilizar uma aplicação web sem dedicar muito tempo a configuração de ambiente.

Antes de criar a aplicação no Heroku, é necessário que sejam feitos alguns ajustes na API para que esta fique pronta para o ambiente de produção. O primeiro passo é instalar o servidor WSGI gunicorn atendendo ao warning exibido ao iniciar a aplicação. Tal mensagem contém: “WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instea.”, informando que o servidor atual deve ser utilizado apenas em desenvolvimento e para o ambiente de produção, deve ser adicionado um servidor WSGI próprio, que nesse caso será o gunicorn.

Ao final da instalação do gunicorn, iremos gerar um arquivo .txt com todas as dependências de nossa aplicação executando o comando pip freeze > requirements.txt. Note que foi gerado um arquivo chamado requirements.txt que contém a lista de dependências bem como a versão específica de cada biblioteca.

Por fim, é necessário definir que a aplicação seja iniciada utilizando o servidor gunicorn, isto é feito adicionando uma linha com a configuração web: gunicorn main:app a um arquivo chamado Procfile. O arquivo Procfile é utilizado pelo Heroku para definir as configurações de inicialização de um ambiente.

Como faremos o deploy através da integração que o Heroku possui com o Github, será necessário fazer um commit com as alterações até aqui e criar um novo repositório como o que criei com o código deste projeto.

Com sua conta no Heroku criada através do link, chegou o momento de fazer o deploy da aplicação. Ao clicar no botão new e selecionando a opção Create new app, você será redirecionado para a tela de criação de um novo app. Lembre-se de que não existem mais Dynos gratuitos, e um Dyno básico é o suficiente para reproduzir a aplicação descrita neste artigo e custa em torno de sete dólares por mês.

Agora deve ser preenchido um nome para a aplicação, que no meu caso foi `iris-prediction-api`. Como o nome é único, deve ser escolhido algo que faça sentido para sua aplicação.

Com o nome da aplicação definido, chegou a hora de enviar nosso código ao `Heroku`. É possível fazê-lo através de um cliente de terminal que o próprio `Heroku` disponibiliza, porém faremos via integração com o `Github`. Com isso, clique na opção `Github` presente na sessão `Deployment method` e siga os passos para dar acesso ao `Heroku` a seus repositórios presentes no `Github`.

Uma vez que a integração estiver concluída, utilize o filtro para selecionar o nome do repositório e clique em `connect`. Após conectado com o repositório, selecione a `branch` que contém o código de produção, que no meu caso é a branch `main` e clique no botão `Deploy branch` para que seja iniciado o processo de deploy. Note que existe uma opção que permite ligar o deploy automático e, com isso, sempre que a branch selecionada for atualizada será feito um novo deploy automaticamente.

É possível acompanhar os passos que estão sendo executados bem como o status do `deploy`.

Com o fim da etapa de deploy, chegou o momento de testar se a API está funcionando corretamente. Clique no botão `Open app` e copie a `URL` da aba que foi aberta. Esta é a `URL` que aponta para a `API` e com isso é possível fazer uma requisição via `cURL` apontando para o servidor de produção.

Por fim,temos uma API `Flask` que disponibiliza um modelo de classificação para que seja utilizado por outros apps. O código utilizado como exemplo ao longo do artigo está neste repositório.

Até o próximo artigo!

Na parte 2 desse módulo aprendemos a como utilizar os parâmetros da URL, para possibilitar uma navegação ainda mais fluida e completa dentro da nossa aplicação. Nessa terceira parte do artigo iremos aprender a como tratar erros e por consequência enviar um feedback, isto é, uma resposta para o usuário de que ocorreu algum erro dentro da nossa aplicação. Para isso, iremos dar continuidade ao projeto que estamos utilizando desde a parte 1 do artigo, se você chegou aqui de paraquedas e quer pegar essa explicação desde o início acesse esse link

Qual é a importância de lidar com erros?

Lidar com erros de maneira eficaz é fundamental para criar uma experiência de usuário positiva e funcional em qualquer aplicação ou sistema. A importância de tratar erros está relacionada a diversos aspectos que impactam diretamente a usabilidade, a confiabilidade e a credibilidade da aplicação. Vamos explorar algumas razões pelas quais é essencial lidar com erros de forma adequada:

Experiência do Usuário (UX) Melhorada: Erros não tratados ou mensagens de erro confusas podem frustrar os usuários e dificultar o uso da aplicação. Quando os usuários não entendem o que deu errado e por que, eles podem se sentir desencorajados a continuar usando o aplicativo. Por outro lado, tratar erros de maneira clara e fornecer feedback compreensível pode melhorar a experiência do usuário, permitindo que eles compreendam o problema e saibam como resolvê-lo. Nós não queremos que o usuário veja um erro desse tipo, seria um susto para ele:

Identificação e Resolução de Problemas: Ao lidar com erros de forma estruturada, a equipe de desenvolvimento (que somos nós, desenvolvedores) pode coletar informações úteis sobre o que deu errado e por quê. Isso facilita a identificação e a resolução de problemas, permitindo que os desenvolvedores abordem as questões subjacentes e melhorem a qualidade do aplicativo ao longo do tempo.

Navegação Fluida: Lidar com erros na URL, como mencionado na introdução, é um exemplo de como tratar erros pode melhorar a navegação fluida na aplicação. Se a aplicação não consegue lidar com URLs inválidas ou malformadas, os usuários podem ficar presos em páginas de erro ou redirecionamentos inesperados, o que prejudica a usabilidade.

Exemplificando erros: No desenvolvimento da nossa aplicação estamos usando um contexto baseado em um site que possui alguns produtos, que nesse caso são jogos. Voltando para a parte 2 do artigo, nós utilizamos o useParams() para usar os parâmetros da URL, mas vamos supor que o usuário tentou acessar um produto que não existe dentro do nosso banco de dados: o arquivo database.json. Isso dará um erro na nossa aplicação, sem dúvidas. Para acessar o que seria mostrado para o usuário, na URL da aplicação, ao invés de acessarmos um valor válido de ID (que no caso vai de 1 até 5) vamos passar um valor inválido que seja maior do que 5 e menor do que 1. Veja só, irei passar o valor 1000:

Como você pode observar, o produto 1000 evidentemente não existe na lista dos nossos produtos e como consequência disso a nossa aplicação dar um erro! Inclusive, o próprio React nos dar uma dica: “💿 Hey developer 👋

You can provide a way better UX than this when your app throws errors by providing your own ErrorBoundary or errorElement prop on your route.” Ele avisa para nós desenvolvedores que nós poderíamos criar uma tela de erro que possuísse um melhor UX do que a tela de erro padrão do React (que é imagem acima), usando ErrorBoundary ou errorElement.

Então é isso que aprenderemos nesse artigo!

Configurando mecanismos de erros

Dentro da pasta src, iremos criar duas novas pastas separadas: loaders e errorBoundaries.

Explicando o loader: o loader é uma propriedade disponível dentro dos caminhos das rotas da nossa aplicação, e elas servem exatamente para carregar algum conteúdo: seja ele uma requisição à API, carregar informações de um banco de dados e entre outros. O loader é uma função que deve retornar alguma coisa, algum carregamento.

Explicando errorBoundary: o errorBoundary é um elemento que vai ficar “observando” se determinada rota vai ocorrer algum tipo de erro, e se caso aconteça irá ser tratado de alguma forma de acordo com o que foi projetado.

As pastas devem estar assim:

Agora dentro da pasta loaders iremos criar um arquivo chamado products. Isso seria o arquivo responsável por fazer alguma requisição e retornar algo, por exemplo. No nosso exemplo, a “requisição” será feita para o database.json retornar o produto que queremos acessar a partir do parâmetro da função da rota que estamos usando o loader (que nesse caso é o productId). Por esse motivo, usamos a prop params que já é uma prop disponível em todo loader, que vai usar o parâmetro específico da rota em que está inserida. Dentro desse arquivo estará assim:

Agora vamos retornar o produto específico que queremos, igual fizemos no arquivo Product.jsx anteriormente em outro artigo. Iremos procurar esse produto baseado no seu parâmetro e retorná-lo:

No arquivo Product.jsx podemos deixá-lo assim:

Agora, dentro do arquivo router.jsx é necessário incluir o nosso loader:

Agora falta a última etapa para concluir o carregamento do loader, que é usá-lo. Se formos até o arquivo Product.jsx vamos ver que não retornamos nada para product:

Isso está acontecendo justamente porque ainda não usamos o loader, que é o responsável por carregar nossa “requisição”, que são os produtos. Para isso vamos usar um hook chamado userLoaderData(), que vai basicamente capturar o retorno da função do loader que criamos! Logo, o arquivo Product.jsx ficará assim:

OBSERVAÇÃO IMPORTANTE: no arquivo product.js, que está dentro da pasta loaders, altere o nome da função para loadProduct! Se você não fizer isso haverá conflito com o database.json:

Usando o errorElement

Após terminarmos todas as configurações do loader acima, vamos começar a tratar e visualizar de fato os erros. Antes de prosseguir, vale ressaltar que para que possamos utilizar o errorElement de maneira completa e eficiente é necessária a configuração de um loader para a rota que queremos tratar erros, logo é um requisito obrigatório essa configuração que fizemos anteriormente.

Dentro da pasta errorBoundaries, vamos criar um componente chamado ProductBoundary, e dentro dele deve ter o seguinte conteúdo:

const error = useRouterError();

A linha de código acima é um outro hook do React Router DOM, que vai retornar o erro mais próximo da rota em que ele estar inserido. E por meio desse erro, podemos tratá-los de acordo com a necessidade.

if (isRouteErrorResponse(error)) {

}

A linha de código acima verifica se o erro que foi retornado é um erro de resposta de rota:

404 - Não Encontrado: O servidor não encontrou o recurso solicitado. Isso é frequentemente usado para representar que uma rota não corresponde a nenhuma das rotas definidas na aplicação.

401 - Não Autorizado: O acesso ao recurso é negado devido à falta de autenticação válida ou à autenticação inválida. Isso pode ser usado para roteamento quando um usuário não tem permissão para acessar determinada rota.

403 - Proibido: O servidor entendeu a solicitação, mas se recusa a autorizá-la. Diferente do 401, aqui o usuário está autenticado, mas não possui as permissões necessárias.

500 - Erro Interno do Servidor: Indica que o servidor encontrou uma situação com a qual não sabe lidar. Pode ser usado para indicar um erro interno ao renderizar uma rota.

502 - Bad Gateway: Indica que um servidor, enquanto atuando como gateway ou proxy, recebeu uma resposta inválida do servidor upstream que estava acessando para atender a solicitação.

503 - Serviço Indisponível: O servidor não está pronto para manipular a solicitação. Isso pode ocorrer, por exemplo, quando o servidor está sobrecarregado ou em manutenção.

504 - Gateway Timeout: O servidor, enquanto atuando como gateway ou proxy, não recebeu uma resposta oportuna do servidor upstream ou algum outro servidor necessário para lidar com a solicitação.

Essa verificação decorrente desse Hook, possibilita acessar uma propriedade do objeto pela qual ele retorna chamada: status. Dessa forma, podemos tratar os erros com uma precisão muito melhor:

Agora basta usarmos o errorElement passando o componente que criamos, dentro do arquivo router.jsx:

Agora, no navegador podemos tentar acessar algum produto que não existe, e veremos que está tudo funcionando:

Analisando os outros tipos de erros de resposta de rota

Dentro do nosso arquivo loader chamado product.js vamos lançar um erro de resposta personalizado para que possamos analisar e verificar se todos os erros realmente estão funcionando. Para isso, seu arquivo deve analisar se caso o produto não exista, lançar um erro de resposta de forma manual:

}

No navegador, a mensagem de erro mudará pois lançamos um erro do tipo 404 e mensagem aparecerá de acordo com o que definimos no switch case:

Para verificar os outros erros basta mudar o status do erro lançado. Não esqueça de atualizar a página no seu navegador para que veja o novo erro!

Conclusão

Em conclusão, esta terceira parte do artigo aprofundou nosso conhecimento sobre a importância de tratar erros de forma adequada em aplicações. Como vimos ao longo do artigo, lidar com erros não é apenas uma questão técnica, mas também desempenha um papel fundamental na criação de uma experiência de usuário positiva e funcional.

Através da abordagem cuidadosa de tratamento de erros, conseguimos compreender como a usabilidade, a confiabilidade e a credibilidade de uma aplicação podem ser diretamente impactadas. Ao proporcionar mensagens de erro claras e informativas, podemos evitar frustrações por parte dos usuários e incentivá-los a continuar utilizando a aplicação, mesmo diante de adversidades.

Assim como um sistema bem projetado é capaz de minimizar erros técnicos, um tratamento de erros eficaz pode minimizar as consequências negativas de eventuais problemas. Ao investir tempo e esforço na implementação de estratégias de feedback e comunicação de erros, estamos contribuindo para a construção de produtos de qualidade e para a satisfação duradoura dos usuários.

Portanto, ao prosseguir com o projeto que acompanhamos desde a primeira parte deste artigo, convido você a aplicar os conhecimentos adquiridos aqui. Implemente uma abordagem de tratamento de erros que não apenas solucione problemas, mas também ofereça uma experiência que inspire confiança e facilite a resolução de dificuldades por parte dos usuários.

Agradeço por ter me acompanhado nesta jornada de aprendizado e aprimoramento. Com as bases sólidas estabelecidas nas três partes deste artigo, você está bem equipado para criar aplicações mais robustas, eficazes e amigáveis com React Router DOM. Lembre-se sempre de que a busca pela excelência no tratamento de erros é um passo essencial para o sucesso de qualquer projeto de desenvolvimento.

Se você deseja revisitar alguma parte deste artigo, pode encontrar os links para as partes anteriores abaixo:

Parte 1

Parte 2

Continuarei a explorar temas relevantes como este para enriquecer seu conhecimento e habilidades no desenvolvimento de software. Fique atento para mais conteúdo envolvente e educativo.

Até a próxima jornada!

Realizar o deploy de um projeto é um passo crucial para o desenvolvimento web. Dentre tantas plataformas de hospedagem existentes hoje em dia, a Vercel é uma que se destaca pela facilidade de uso e pela integração perfeita com frameworks como o Next.js. Neste artigo, vamos realizar juntos o deploy diretamente pelo site da Vercel de um projeto React com Next.js, de forma simples e eficaz, para que você também possa aplicar em seus projetos.

Se você ainda não está entendendo nada do que eu estou falando, vamos por partes: que tal revisar o que é o React, o Next.js e a Vercel e por que eles são uma combinação tão poderosa para o desenvolvimento e implantação de aplicações web modernas?

O que é o React?

O React é uma biblioteca JavaScript de código aberto desenvolvida pelo Facebook que permite aos desenvolvedores construir interfaces de usuário interativas e dinâmicas para aplicativos web e móveis. Ele utiliza um modelo de componentes reutilizáveis, onde cada parte da interface é encapsulada em componentes independentes, facilitando o desenvolvimento, manutenção e escalabilidade de aplicativos. Além disso, esta biblioteca utiliza uma abordagem de "renderização virtual" para otimizar o desempenho, atualizando apenas partes específicas da interface quando necessário, resultando em uma experiência de usuário mais responsiva.

O que é o Next.js?

O Next.js é um framework de código aberto construído sobre o React que simplifica o desenvolvimento web. Destaca-se por oferecer renderização no lado do servidor (SSR) para melhor desempenho e SEO, integração fácil com TypeScript, sistema de rotas intuitivo e suporte a diversos plugins, tornando-o uma escolha popular para criar aplicações web modernas e eficientes. Para utilizar o Next.js, você precisa ter o Node.js instalado em seu terminal. Caso esteja usando um sistema operacional Mac ou Windows, você pode acessar o site https://nodejs.org/en/ para fazer o download da versão LTS (Long Term Support) mais recente e estável do Node.js e, em seguida, realizar a instalação usando o arquivo baixado. Caso esteja utilizando o sistema operacional Linux, você pode executar as seguintes linhas de comando no seu terminal para instalar o Node.js:

sudo apt-get update
sudo apt-get install node.js

Se a instalação do Node foi concluída corretamente para qualquer um dos casos citados, ao executarmos o comando abaixo, receberemos como informação no nosso terminal a versão do Node instalada:

node --version

O que é o Vercel?

A Vercel é uma plataforma de hospedagem de aplicativos web que se destaca por sua especialização em aplicativos front-end e oferece uma variedade de recursos e benefícios para desenvolvedores.

A Vercel é amplamente reconhecida por sua eficácia na hospedagem de projetos construídos com frameworks front-end populares, como Next.js e React, mas também é adequada para uma variedade de outros frameworks e tecnologias. Com suporte a domínios personalizados, certificados SSL gratuitos e uma série de ferramentas de colaboração e monitoramento, a Vercel se torna uma escolha preferencial para aqueles que buscam uma plataforma robusta e amigável para hospedar seus projetos web.

Você deve possuir uma conta na Vercel para realizar o deploy por lá. Se não tiver uma, é possível criar uma gratuitamente clicando aqui e se cadastrando.

Primeiros passos

Agora, com a conta na Vercel criada e o Node.js instalado para o uso do Next.js, vamos prosseguir com o passo a passo. Primeiramente, crie um projeto React na sua máquina, por meio do código a seguir:

npx create-next-app pokedex

Responda aos questionamentos que surgirão de acordo com as configurações que você deseja para a sua aplicação e, ao concluir todos os passos, inicialize um terminal no diretório raiz da sua aplicação. Caso tenha dado tudo certo, a seguinte página ficará disponibilizada no endpoint fornecido no terminal:

Após isso, lá no GitHub, iremos criar um repositório que irá armazenar o projeto que temos. Na página inicial do Github, clique no botão “new”. Após isso, preencha os dados necessários (proprietário, nome do repositório e descrição), mantenha o repositório como público e, por fim, clique em “Criar repositório”.

Feitas todas estas configurações no Github, você deve executar, em um terminal inicializado no diretório raiz do seu projeto, os comandos a seguir, com o intuito de realizar o “push” de sua aplicação para o GitHub:

git add .
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin git@github.com {usuário}/{projeto}.git
git push -u origin main

OBS - Substitua “{usuário}” por seu nome de usuário existente lá no Github. Faça o mesmo para “{projeto}”, inserindo o nome exato que você deu ao projeto no ato de criação.

Uma vez com seu projeto devidamente atualizado e armazenado no Github, podemos ir para o Vercel.

Configurando o Vercel

No painel principal da Vercel (depois de estar devidamente logado), você deve seguir os seguintes passos:

1. Clique no botão “Add New…“. Surgirão diversas opções, mas, você deve escolher a opção Project. Você será direcionado para uma nova página, onde poderá configurar qual das suas contas do Github, caso tenha mais de uma, está localizado o projeto.

2. Abaixo de Import Git Repository, garanta que é o usuário certo que está conectado e, caso não seja, realize a mudança em “Add Github Account”.

OBS - O exemplo que escolhemos fazer utiliza a integração entre o Vercel e o GitHub, mas você também pode utilizar o GitLab ou Bitbucket tranquilamente, sem extremas mudanças.

3. Procure o projeto pelo nome que você deu a ele no ato de criação do mesmo:

4. Após conectar o repositório, a Vercel detecta automaticamente o tipo de projeto. No caso de um projeto Next.js, ele será identificado como um projeto Node.js, como podemos ver na figura 4.

5. Após encontrar o seu repositório, clique em “Import”.

6. Escolha um nome para seu projeto na Vercel. Este nome será usado na URL da aplicação.

7. Configure as opções de implantação, como a branch a ser implantada e o diretório onde o projeto está localizado.

8. Este também é o momento de criar variáveis de ambiente, caso seja necessário. Variáveis de ambiente são valores que são confidenciais demais para estarem soltos dentro do código que nós estamos desenvolvendo. Essas variáveis são usadas para armazenar informações temporárias ou configurações que podem ser acessadas pelo sistema operacional ou por aplicativos em execução. São comumente utilizadas para guardar dados de conexão com a devida segurança, como usuário e senha de um banco de dados, ou a porta que o mesmo funciona, etc. Como elas não vão para repositórios públicos (para não vazar informações confidenciais), precisamos criá-las no Vercel.

OBS - Caso seja necessário criar variáveis de ambiente que funcionam no lado cliente, você pode criá-las com o prefixo “NEXT_PUBLIC_” junto ao nome da variável, além de realizar estas criações dentro de um arquivo env.local, no diretório raiz do projeto.

9. Por fim, e não menos importante, clique em Deploy e aguarde o prazo para que este seja concluído.

A Vercel iniciará o processo de implantação, e você poderá acompanhar o progresso diretamente no painel. Após a conclusão bem-sucedida da implantação, a Vercel fornecerá um URL público onde sua aplicação estará acessível na web. Você pode acessar esse URL para verificar o funcionamento de sua aplicação.

A partir do painel da Vercel, você pode gerenciar seu projeto, configurar domínios personalizados, definir variáveis de ambiente e muito mais.

E, por fim, se você quiser atualizar o seu projeto, basta atualizar a sua versão armazenada no repositório Github que você realizou a integração no Vercel, que automaticamente, depois de alguns minutos, sua versão em deploy também será atualizada!

Considerações finais

Realizar o deploy de um projeto React com Next.js no Vercel diretamente pelo site da plataforma é um processo simplificado e eficaz. A Vercel oferece uma plataforma sólida para hospedar aplicativos front-end, e a integração com o Next.js é suave e intuitiva. Lembre-se de que, ao implantar em um ambiente de produção, é fundamental garantir que seu código esteja otimizado, configurar variáveis de ambiente apropriadas e considerar a escalabilidade de sua aplicação.

Desejamos que aproveitem ao máximo as poderosas ferramentas e recursos oferecidos por essas tecnologias para criar aplicativos web incríveis e compartilhá-los com o mundo, inclusive conosco. Após ler este artigo, você está pronto para implantar seu projeto Next.js na Vercel através do site da plataforma, simplificando o processo e compartilhando suas criações com eficiência.

Pratique, replique e ensine, pois não há forma melhor de fixar um conhecimento adquirido!Se você achou esse artigo interessante, gostaria de tirar quaisquer dúvidas ou somente está a fim de trocar uma ideia sobre esses e mais assuntos, você também pode entrar em contato comigo, seja por meio do e-mail bruno.cabral.silva2018@gmail.com ou pelo meu perfil do LinkedIn!

Te espero ansiosamente!

Threat Intelligence é o conhecimento que possibilita a prevenção e a redução de ataques cibernéticos. É um processo de coleta, análise e disseminação de informações sobre ameaças cibernéticas. Essas informações podem ser usadas para proteger organizações de ataques, melhorar a resposta a incidentes e tomar decisões informadas sobre segurança cibernética.

Cyber Threat Intelligence é uma ferramenta valiosa para organizações de todos os tamanhos. Ela pode ajudar a proteger as organizações contra uma variedade de ameaças, incluindo:

• Ataques de ransomware

Os ataques de ransomware são um tipo de ataque cibernético em que os invasores criptografam os dados de uma vítima e exigem um resgate para descriptografá-los. Os ataques de ransomware estão se tornando cada vez mais comuns e sofisticados, e podem ter um impacto devastador nas organizações.

As organizações que são vítimas de ataques de ransomware podem sofrer uma série de danos, incluindo:

Perda de dados: Os dados criptografados podem ser irreparáveis, o que pode levar à perda de dados valiosos, como informações de clientes, registros financeiros e segredos comerciais.

Interrupção dos negócios: Os ataques de ransomware podem interromper as operações de negócios, o que pode levar a perda de receita e danos à reputação.

Custos de recuperação: As organizações podem precisar gastar dinheiro para recuperar seus dados e restaurar suas operações, o que pode ser caro e demorado.

• Ataques de phishing

Os ataques de phishing são um tipo de ataque cibernético em que os invasores se passam por uma fonte confiável, como uma empresa ou uma organização, para enganar as vítimas a fornecer informações pessoais ou clicar em um link malicioso. Os ataques de phishing são uma das formas mais comuns de ataques cibernéticos e podem ter um impacto devastador nas vítimas.

As vítimas de ataques de phishing podem sofrer uma série de danos, incluindo:

Roubo de identidade: Os invasores podem usar as informações pessoais da vítima para abrir contas em seu nome, fazer compras online ou obter empréstimos.

Perda financeira: Os invasores podem usar as informações financeiras da vítima para fazer compras online ou sacar dinheiro de suas contas.

Infecção por malware: O malware instalado no dispositivo da vítima pode roubar dados, danificar os sistemas ou até mesmo controlar o dispositivo remotamente.

• Ataques de malware

Os ataques de malware são um tipo de ataque cibernético em que os invasores usam software malicioso, ou malware, para causar danos a um sistema ou rede. O malware pode ser usado para roubar dados, danificar sistemas ou até mesmo controlar sistemas remotamente.

Ataques de phishing: Os invasores enviam um e-mail ou mensagem de texto malicioso que, quando aberto, instala o malware no dispositivo da vítima.

Ataques de download: Os invasores tentam convencer a vítima a baixar um arquivo malicioso, geralmente camuflado como um arquivo legítimo.

Ataques de exploração: Os invasores exploram vulnerabilidades de software para instalar o malware em um sistema.

Injeção de código: Os invasores injetam código malicioso em um sistema ou rede.

Ataques de dia zero: Os invasores usam vulnerabilidades de software que ainda não foram corrigidas.

• Ataques de negação de serviço (DoS)

Um ataque de negação de serviço (DoS) é um tipo de ataque cibernético em que os invasores inundam um sistema ou rede com tráfego malicioso, tornando-o inacessível aos usuários legítimos.

Ataques de inundação: Os invasores enviam uma grande quantidade de tráfego malicioso para um sistema ou rede, fazendo com que ele não consiga lidar com a carga e fique indisponível.

Ataques de reflexão: Os invasores usam um dispositivo comprometido para enviar tráfego malicioso para um sistema ou rede, fazendo com que o dispositivo comprometido pareça ser a fonte do ataque.

Ataques de fragmentação: Os invasores enviam pacotes de dados fragmentados para um sistema ou rede, fazendo com que o sistema ou rede não consiga montá-los corretamente.

• Ataques de roubo de dados

Os ataques de roubo de dados são um tipo de ataque cibernético em que os invasores roubam dados confidenciais de uma organização ou indivíduo. Os dados roubados podem ser usados para fins diversos, como fraude, chantagem ou espionagem.

Ataques de engenharia social: Os invasores usam técnicas de engenharia social para enganar a vítima a fornecer dados confidenciais.

Ataques de força bruta: Os invasores usam software para tentar adivinhar as senhas da vítima.

Ataques de sequestro de dados: Os invasores sequestram os dados da vítima e exigem um resgate para devolvê-los.

Threat Intelligence pode ser usada para identificar novas ameaças por meio da coleta de informações de uma variedade de fontes, como:

• Relatórios de segurança;
• Análises de segurança;
• Notícias e mídias sociais;
• Informações de inteligência.

É usada para analisar tendências de ameaças por meio da identificação de padrões em dados de segurança. Esses padrões podem ser usados para identificar ameaças emergentes e para prever ataques futuros.

Etapas Threat Intelligence

1 - Coleta de dados: A coleta de dados é a primeira etapa do processo de inteligência de ameaças. Nesta etapa, a organização coleta informações de uma variedade de fontes, incluindo:

• Relatórios de segurança: Esses relatórios são publicados por organizações de segurança cibernética, como o SANS Institute e o MITRE Corporation. Eles fornecem informações sobre novas ameaças, tendências de ameaças e técnicas de ataque.
• Análises de segurança: Essas análises são realizadas por organizações de segurança cibernética e consultores de segurança. Eles fornecem informações mais detalhadas sobre ameaças específicas.
• Notícias e mídias sociais: As notícias e a mídia social podem ser fontes valiosas de informações sobre ameaças cibernéticas.
• Informações de inteligência: As informações de inteligência podem ser obtidas de agências governamentais e outras fontes. Elas fornecem informações sobre ameaças emergentes e ameaças que estão sendo direcionadas a organizações específicas.
  

2 - Análise dos dados coletados: Nesta etapa, a organização analisa os dados coletados para identificar ameaças e tendências de ameaças.

O processo de análise de dados pode ser dividido em várias etapas:

• Filtragem: Os dados coletados são filtrados para remover informações irrelevantes.
• Filtragem baseada em regras: Este método usa regras predefinidas para determinar se um dado deve ser mantido ou removido. As regras podem ser baseadas em critérios como o tipo de dados, o valor dos dados ou a fonte dos dados.
• Filtragem baseada em aprendizado de máquina: Este método usa algoritmos de aprendizado de máquina para aprender padrões nos dados e usar esses padrões para identificar informações relevantes.
• Filtragem baseada em Inteligência Artificial: Este método usa técnicas de inteligência artificial, como aprendizado de máquina e processamento de linguagem natural, para identificar informações relevantes.
• Normalização: Os dados são normalizados para facilitar a análise.
• Padronização de formatos: Este método usa um formato comum para representar os dados. Isso pode ajudar a garantir que os dados possam ser lidos e interpretados por diferentes sistemas.
• Padronização de nomes: Este método usa um nome comum para representar as mesmas informações. Isso pode ajudar a garantir que os dados possam ser facilmente localizados e identificados.
• Padronização de valores: Este método usa um valor comum para representar a mesma informação. Isso pode ajudar a garantir que os dados possam ser comparados de forma eficaz.
• Análise: Os dados são analisados para identificar padrões e tendências.
• Análise estatística: Este método usa métodos estatísticos para identificar tendências e padrões nos dados.
• Análise de texto: Este método usa técnicas de processamento de linguagem natural para identificar tendências e padrões nos dados de texto.
• Análise de rede: Este método usa técnicas de análise de rede para identificar relacionamentos entre os dados.
• Segurança: Os dados são analisados para identificar vulnerabilidades de segurança.
• Usar senhas fortes e exclusivas: As senhas são a primeira linha de defesa contra ataques cibernéticos. É importante usar senhas fortes e exclusivas para todos os sistemas e contas.
• Manter os sistemas atualizados: As atualizações de software geralmente incluem correções de segurança que podem ajudar a proteger contra ataques cibernéticos. É importante manter todos os sistemas atualizados com as últimas atualizações de segurança.
• Usar software antivírus e anti-malware: O software antivírus e anti-malware pode ajudar a proteger contra uma variedade de ameaças cibernéticas, incluindo vírus, malware e ransomware.
• Implementar medidas de segurança de rede: As medidas de segurança de rede, como firewalls e intrusion detection systems (IDSs), podem ajudar a proteger contra ataques cibernéticos de entrada e saída.
• Educar os funcionários sobre segurança cibernética: Os funcionários são muitas vezes o elo mais fraco na segurança cibernética. É importante educar os funcionários sobre as ameaças cibernéticas e como se proteger.
  

3 - Disseminação de informações: A terceira etapa é a disseminação das informações analisadas. Essas informações podem ser compartilhadas com uma variedade de partes interessadas, incluindo:

• Equipes de segurança cibernética: Essas equipes são responsáveis por proteger a organização de ataques.
• Executivos: esses executivos tomam decisões sobre a segurança cibernética da organização.
• Funcionários: esses funcionários são responsáveis por ajudar a proteger a organização de ataques.
  

Formas específicas de disseminação de informações

• Relatórios de inteligência de ameaças: esses relatórios fornecem uma visão geral das ameaças cibernéticas atuais e emergentes.
• Alertas de segurança: esses alertas fornecem informações sobre ameaças específicas ou eventos de segurança.
• Treinamentos de segurança: esses treinamentos ajudam as pessoas a identificar e evitar ameaças cibernéticas.

A disseminação de informações pode ajudar as equipes de segurança cibernética a identificar e responder a ataques.

Ajudar os executivos a tomar decisões adequadas sobre a segurança cibernética.

4 - Ação: Etapa em que a organização toma medidas para proteger a organização de ataques com base nas informações compartilhadas na etapa anterior.

As medidas que as organizações podem tomar incluem:

• Implementação de correções de segurança: as correções de segurança podem ajudar a fechar as vulnerabilidades que os cibercriminosos podem explorar.
• Treinamento de funcionários: o treinamento de funcionários pode ajudar os funcionários a identificar e evitar ameaças cibernéticas.
• Melhoria dos controles de segurança: os controles de segurança podem ajudar a proteger a organização de ataques.

A organização deve desenvolver um plano de ação eficaz que garanta que as medidas sejam tomadas de forma oportuna e eficaz.

Uma organização pode implementar uma correção de segurança para fechar uma vulnerabilidade que foi identificada por meio da inteligência de ameaças. Essa correção pode ajudar a proteger a organização de ataques de malware que exploram essa vulnerabilidade.

Treinar seus funcionários sobre como identificar e evitar ataques de phishing. Esse treinamento pode ajudar a proteger a organização de ataques de phishing que usam técnicas de engenharia social para enganar os funcionários.

Melhorar seus controles de segurança para dificultar que os cibercriminosos acessem seus sistemas e dados. Essas melhorias podem ajudar a proteger a organização de ataques de ransomware que visam criptografar seus dados e exigir resgate.

A organização deve revisar e atualizar seu plano de ação regularmente para garantir que ele seja eficaz contra as ameaças mais recentes.

A Cyber Threat Intelligence oferece uma variedade de benefícios para organizações de todos os tamanhos. Esses benefícios incluem:

• Melhor proteção contra ataques
• Monitorando fontes abertas: As organizações podem monitorar fontes abertas, como notícias, blogs e fóruns, para identificar novas ameaças cibernéticas. Isso pode ajudar as organizações a se preparar para essas ameaças e tomar medidas para mitigá-las.
• Usando ferramentas de análise de dados: As organizações podem usar ferramentas de análise de dados para identificar tendências e padrões em dados de ameaças. Isso pode ajudar as organizações a identificar vulnerabilidades e desenvolver estratégias de mitigação.
• Trabalhando com parceiros: As organizações podem trabalhar com parceiros de Inteligência para obter acesso a informações e insights sobre ameaças cibernéticas. Isso pode ajudar as organizações a manter-se atualizadas sobre as últimas ameaças e tecnologias.
• Maior eficiência na resposta a incidentes
• Comunicação: Ajudar a organizar e coordenar a comunicação entre as diferentes equipes envolvidas na resposta a incidentes. Isso pode ajudar a garantir que todos estejam na mesma página e trabalhando juntos para resolver o problema.
• Analítica: Usar ferramentas de análise de dados para identificar tendências e padrões em dados de incidentes. Isso pode ajudar as organizações a aprender com os erros e melhorar suas respostas futuras.
• Automatização: Usar automação para automatizar tarefas rotineiras relacionadas à resposta a incidentes. Isso pode ajudar as organizações a economizar tempo e recursos.
• Melhor tomada de decisões sobre segurança cibernética
• Fornecer insights: A TI pode fornecer insights sobre as ameaças cibernéticas que as organizações enfrentam. Isso pode ajudar as organizações a priorizar seus esforços de segurança.
• Modelagem de risco: A TI pode usar modelos de risco para ajudar as organizações a avaliar o risco de ataques cibernéticos. Isso pode ajudar as organizações a tomar decisões mais informadas sobre como alocar seus recursos de segurança.
• Simulação de ataques: A TI pode usar simulações de ataques para ajudar as organizações a testar suas defesas cibernéticas. Isso pode ajudar as organizações a identificar vulnerabilidades e melhorar sua capacidade de responder a ataques.

Desafios da Threat Intelligence

• Volume de dados: O volume de dados de ameaças cibernéticas está crescendo exponencialmente. Isso ocorre porque há mais dispositivos conectados à internet, mais dados sendo gerados e mais ataques cibernéticos sendo executados.

O volume crescente de dados de ameaças cibernéticas representa um desafio para as organizações. É difícil para as organizações coletar, armazenar e analisar grandes quantidades de dados. Isso pode levar a atrasos na identificação de ameaças cibernéticas e na implementação de medidas de mitigação.

• Complexidade dos dados: Os dados de ameaças cibernéticas podem ser complexos e difíceis de entender. Isso ocorre porque os dados podem ser provenientes de uma variedade de fontes, incluindo fontes abertas, fontes privadas e fontes governamentais. Os dados também podem estar em diferentes formatos e idiomas.

A complexidade dos dados de ameaças cibernéticas representa um desafio para as organizações. É difícil para as organizações entender os dados e extrair insights úteis. Isso pode levar a decisões de segurança incorretas.

• Custos: A coleta, armazenamento, análise e distribuição de Threat Intelligence podem ser caros. As organizações precisam investir em ferramentas e recursos para coletar e analisar dados de ameaças cibernéticas. Elas também precisam investir em treinamento e conscientização para que os funcionários possam entender e usar as informações de Inteligência.

Os custos associados à Inteligência de ameaças representam um desafio para as organizações, especialmente para as pequenas empresas. As pequenas empresas podem não ter recursos financeiros para investir.

Além dos desafios já mencionados, como volume de dados, complexidade dos dados e custos, a Threat Intelligence também pode enfrentar desafios como:

• Desinformação: A desinformação sobre ameaças cibernéticas pode dificultar a identificação e a análise de ameaças.
• Falta de recursos: Organizações com poucos recursos podem ter dificuldade para implementar e manter um processo de TI eficaz.
• Resistência à mudança: Funcionários e executivos podem resistir à mudança, o que pode dificultar a implementação de novas medidas de segurança recomendadas pela TI.

Threat Intelligence e Privacidade

A Threat Intelligence pode coletar um grande volume de dados sobre usuários e organizações. É importante que as organizações implementem medidas de segurança para proteger a privacidade desses dados.

TI pode ser usada para proteger a privacidade:

• Identificar e responder a violações de dados.
• Desenvolver políticas e procedimentos de privacidade.
• Treinar funcionários sobre segurança e privacidade.
• Publicar políticas de privacidade claras e concisas.
• Fornecer aos usuários ferramentas para gerenciar suas informações pessoais.
• Notificar os usuários sobre violações de dados.

Threat Intelligence e Ética

Threat Intelligence pode ser usada para coletar e analisar informações sobre indivíduos e organizações. É importante que as organizações usem de forma ética e responsável.

Coletar apenas as informações necessárias. Não coletar informações pessoais que não sejam necessárias para o propósito pretendido.

Usar as informações de forma responsável. Não usar informações pessoais para outros fins que não aqueles para os quais foram coletadas.

Proteger as informações. Implemente medidas de segurança para proteger as informações pessoais de acesso não autorizado, uso indevido e divulgação.

Dar aos usuários controle sobre suas informações. Dar aos usuários a opção de escolher quais informações pessoais são coletadas e como são usadas.

A inteligência de ameaças é uma ferramenta essencial para as guerras modernas. Ela pode ser usada para uma variedade de propósitos, incluindo:

• Espionagem: Pode ser usada para coletar informações sobre o inimigo, como suas forças, capacidades e planos.

As agências de inteligência podem usar TI para coletar informações sobre o inimigo, como suas forças, capacidades e planos. Por exemplo, os EUA usaram TI para coletar informações sobre os planos de guerra do Iraque antes da invasão de 2003.

• Atividades de sabotagem: Pode ser usada para causar danos ou interromper as operações do inimigo.

Causar danos ou interromper as operações do inimigo. Por exemplo, os EUA usaram TI para causar danos à infraestrutura crítica da Síria durante a guerra civil síria.

• Operações psicológicas: Pode ser usada para manipular a opinião pública ou espalhar desinformação.

Manipular a opinião pública ou espalhar desinformação. Por exemplo, a Rússia usou TI para interferir nas eleições presidenciais dos EUA em 2016.

As guerras modernas são cada vez mais dependentes da tecnologia. As organizações militares precisam estar preparadas para enfrentar ataques cibernéticos e para usar a TI para sua própria vantagem.

Algumas dicas para organizações militares se protegerem do uso da TI para operações psicológicas:

• Educar os funcionários sobre as ameaças cibernéticas e operações psicológicas.
• Investir em segurança cibernética e treinamento de segurança.
• Monitorar as redes e sistemas para atividades suspeitas.
• Compartilhar informações sobre ameaças cibernéticas e operações psicológicas com outras organizações.

A Threat Intelligence é uma ferramenta poderosa que pode ser usada para uma variedade de propósitos, tanto pacíficos quanto militares. À medida que o mundo se torna cada vez mais digitalizado, a importância da Inteligência só aumentará. As organizações e indivíduos precisam estar cientes da importância da TI e tomar medidas para se proteger.

Nos vemos na próxima edição!

Em uma população cada vez mais urbana e com trânsito intenso, a busca por vagas de estacionamento pode se tornar uma tarefa frustrante e demorada. Para abordar esse desafio, a tecnologia vem desempenhando um papel crucial na criação de soluções inovadoras.

Neste tutorial, iremos nos aprofundar no desenvolvimento de um Sistema de Estacionamento Inteligente, que utiliza sensores IoT (Internet das Coisas) para informar aos motoristas a disponibilidade de vagas de estacionamento em uma cidade movimentada. Esse sistema não apenas otimiza a busca por estacionamento, mas também contribui para a melhoria da mobilidade urbana e para uma experiência mais conveniente para os motoristas.

O Papel do Raspberry Pi e Sistemas Embarcados

O Raspberry Pi é um exemplo notável de um sistema embarcado que desempenha um papel central em projetos de IoT. O Raspberry Pi é um computador de placa única (SBC - Single Board Computer) que oferece poder de processamento, conectividade e interface de E/S em um pacote compacto. Ele é amplamente utilizado em projetos de IoT devido à sua acessibilidade, versatilidade e suporte à programação Python e outras linguagens. Além do Raspberry Pi, existem outras opções de sistemas embarcados, como Arduino, ESP8266 e ESP32, que também são populares em projetos de IoT e sistemas de monitoramento.

Projetado para fins educacionais, prototipagem e aplicações de computação de baixo custo, o Raspberry Pi oferece poder de processamento, capacidade de entrada e saída, e suporte à execução de sistemas operacionais completos, tornando-se uma plataforma versátil para uma ampla variedade de projetos, desde aprendizado de programação até automação residencial e Internet das Coisas (IoT).

Internet das Coisas (IoT)

A IoT refere-se à interconexão de dispositivos físicos, veículos, edifícios e outros objetos incorporados com sensores, software e conectividade para coleta e troca de dados. No contexto do Sistema de Estacionamento Inteligente, os sensores IoT desempenham um papel vital na coleta de dados em tempo real sobre a ocupação das vagas de estacionamento. Esses dados são então processados e transmitidos para uma interface de usuário, permitindo que os motoristas acessem informações precisas e atualizadas sobre a disponibilidade de vagas.

Ao utilizar o Raspberry Pi e sensores IoT, estamos criando uma rede de dispositivos inteligentes que se comunicam e interagem para fornecer informações valiosas aos usuários. Esse tipo de abordagem está na vanguarda da revolução tecnológica, tornando as cidades mais eficientes, sustentáveis e orientadas a dados.

Neste tutorial, vamos explorar a integração desses elementos para criar um Sistema de Estacionamento Inteligente funcional e eficaz. Desde a configuração dos sensores até o desenvolvimento da interface do usuário e a interação entre esses componentes, você aprenderá como criar um sistema que oferece uma solução prática para um problema urbano comum. A adoção dessas tecnologias pode transformar a forma como interagimos com nosso ambiente urbano, melhorando a qualidade de vida e promovendo um futuro mais conectado e inteligente.

Etapa 1: Definição do Projeto e Objetivos

O projeto tem como objetivo criar um sistema que:

- Utiliza sensores IoT para monitorar e coletar dados sobre a ocupação das vagas de estacionamento.

- Fornecer aos motoristas informações em tempo real sobre a disponibilidade de vagas.

- Contribui para a redução do congestionamento e do tempo gasto na busca por estacionamento.

Etapa 2: Escolha dos Componentes e Tecnologias

Os componentes e tecnologias necessários incluem:

- Sensores de Detecção de Presença: Utilizaremos sensores infravermelhos para detectar a presença de veículos nas vagas.

- Placa Raspberry Pi: Escolhemos a Raspberry Pi para processar os dados dos sensores e enviar informações para a interface do usuário.

- Conexão à Internet: A Raspberry Pi será conectada à internet para atualizar os dados em tempo real.

- Aplicativo Web: Iremos desenvolver uma interface web para os motoristas visualizarem as vagas disponíveis.

Etapa 3: Configuração dos Sensores e Raspberry Pi

1. Conecte os sensores de detecção de presença à Raspberry Pi conforme as instruções do fabricante.

2. Utilize o Raspbian OS na Raspberry Pi e instale as bibliotecas necessárias para os sensores.

Etapa 4: Desenvolvimento da Interface Web

1. Crie um diretório para o projeto e inicie um ambiente virtual Python.

2. Utilize Flask, um framework web em Python, para criar a interface. Crie rotas para a página inicial e para atualizar os dados de disponibilidade.

3. Utilize HTML, CSS e JavaScript para criar a interface de usuário e exibir os dados das vagas disponíveis.

Crie um diretório chamado web interface e dentro dele crie um arquivo chamado app.py:

Etapa 5: Integração dos Dados

1. Desenvolva um script Python na Raspberry Pi para ler os dados dos sensores.

2. Envie os dados para a interface web através de uma requisição HTTP usando uma biblioteca como `requests`.

Crie um arquivo chamado script_sensor.py na Raspberry Pi:

Lembre-se de adaptar e ajustar o código conforme necessário para o seu ambiente e requisitos específicos. Esse é apenas um exemplo básico para demonstrar a ideia do sistema. Certifique-se de instalar as bibliotecas necessárias, como Flask e RPi.GPIO, em suas respectivas plataformas (Raspberry Pi e servidor web).

Etapa 6: Implementação da Lógica de Disponibilidade

1. Na Raspberry Pi, implemente a lógica para interpretar os dados dos sensores e determinar se uma vaga está disponível ou ocupada.

2. Atualize os dados de disponibilidade no servidor.

Etapa 7: Testes e Ajustes

1. Realize testes para verificar se os sensores estão detectando corretamente a presença de veículos.

2. Verifique se a interface web exibe corretamente os dados de disponibilidade.

3. Faça ajustes na lógica e na interface conforme necessário.

Etapa 8: Implantação

1. Instale a Raspberry Pi em locais reais de estacionamento.

2. Garanta que a Raspberry Pi esteja conectada à internet.

Etapa 9: Manutenção e Monitoramento Contínuo

1. Monitore o sistema para garantir que os sensores e a interface web estejam funcionando corretamente.

2. Realize atualizações e manutenções conforme necessário.

Conclusão

A criação deste Sistema de Estacionamento Inteligente, utilizando sensores IoT para indicar a disponibilidade de vagas, representa um passo significativo em direção a uma maior eficiência e conveniência nas áreas urbanas movimentadas. Ao longo deste tutorial, exploramos desde a definição do projeto até a integração dos componentes, demonstrando como a tecnologia pode ser aplicada de maneira prática para resolver desafios cotidianos.

A tecnologia IoT desempenhou um papel crucial nesse projeto, permitindo a interconexão dos sensores de detecção de presença, a Raspberry Pi e a interface web. Isso resultou em um ecossistema inteligente capaz de coletar dados em tempo real, processá-los e disponibilizá-los aos motoristas de forma acessível e eficaz.

O Raspberry Pi e outros sistemas embarcados, como Arduino e ESP8266, apresentam uma gama de possibilidades para projetos de IoT e sistemas de monitoramento. Eles oferecem a capacidade de processamento e conectividade necessárias para criar soluções inovadoras, como o Sistema de Estacionamento Inteligente abordado aqui.

A Internet das Coisas (IoT) amplifica a conectividade entre dispositivos e a coleta de dados, transformando as cidades em ambientes mais inteligentes e interconectados. Ao aplicar essas tecnologias em soluções urbanas, como o Sistema de Estacionamento Inteligente, estamos contribuindo para a melhoria da qualidade de vida, a otimização dos recursos e a redução dos problemas relacionados à mobilidade.

Portanto, à medida que continuamos avançando na era da tecnologia, projetos como esse representam um vislumbre do potencial que a inovação e a conectividade podem trazer para as nossas vidas diárias. O Sistema de Estacionamento Inteligente não é apenas um exemplo de como a tecnologia pode resolver problemas complexos, mas também um reflexo do papel transformador que ela desempenha na criação de um futuro mais inteligente, eficiente e sustentável. Este tutorial é apenas o ponto de partida para explorar ainda mais as possibilidades oferecidas pela IoT e sistemas embarcados, incentivando você a continuar a explorar, experimentar e criar soluções que tenham um impacto positivo em nossa sociedade em constante evolução.

Este tutorial não apenas fornece um exemplo prático de como desenvolver um Sistema de Estacionamento Inteligente, mas também incentiva você a aplicar esses conceitos e tecnologias em suas próprias criações. A revolução da IoT está apenas começando, e sua capacidade de criar soluções inovadoras tem o potencial de transformar o mundo ao seu redor. Lembre-se de que a aprendizagem contínua, a experimentação e a colaboração com a comunidade são elementos-chave para impulsionar o avanço tecnológico e criar um impacto positivo em nossa sociedade.

Referências Bibliográficas

1. Raspberry Pi Foundation. (https://www.raspberrypi.org/)

2. Arduino. (https://www.arduino.cc/)

3. ESP8266 Community Forum. (https://www.esp8266.com/)

4. Shinar, D. (2018). A review of sensing technologies for smart parking. Sensors, 18(7), 2066. (https://www.mdpi.com/1424-8220/18/7/2066)

5. Internet of Things: How IoT is Reshaping the Automotive Industry. (https://www.iotforall.com/iot-reshaping-automotive-industry/)

6. Flask Documentation. (https://flask.palletsprojects.com/en/2.1.x/)

7. RPi.GPIO Documentation. (https://sourceforge.net/p/raspberry-gpio-python/wiki/)

O mundo digital é um vasto repositório de informações em diversos formatos, e os arquivos PDF (Portable Document Format) são amplamente empregados para compartilhar conteúdo de maneira confiável e padronizada. Contudo, manipular e extrair dados específicos de arquivos PDF pode ser um desafio, especialmente quando a meta é automatizar esses processos em um ambiente de desenvolvimento.

Neste sentido, a linguagem de programação node.js surge como uma ferramenta eficaz capaz de superar esses desafios. Este tutorial foi criado para guiar você através da superação desse desafio, usando a poderosa plataforma de programação Node.js em conjunto com a biblioteca "pdf-parse". Com o Node.js, é possível construir um código eficaz para ler arquivos PDF e extrair informações relevantes contidas neles. Além disso, vamos explorar como integrar essa funcionalidade com um banco de dados PostgreSQL, permitindo armazenar e organizar os dados extraídos dos arquivos PDF.

Portanto, leia para explorar, com maior exatidão, a possibilidade da extração de dados de arquivos PDF, utilizando o node.js, enriquecendo suas habilidades de desenvolvimento com mais essa ferramenta valiosa em seu repertório.

Antes de adentrarmos no tema, é indispensável preparar o ambiente adequado. Certifique-se de ter o Node.js instalado em seu sistema, já que ele servirá como base para a construção do código. Caso o Node.js não esteja presente, você pode baixá-lo e instalá-lo com facilidade diretamente do site oficial do Node.js (https://nodejs.org/).

Depois de ter o Node.js instalado, vamos criar um novo diretório para o nosso projeto e instalar as bibliotecas necessárias. O npm, que é o gerenciador de pacotes padrão do Node.js, nos ajudará nessa tarefa. As bibliotecas fs e path são recursos nativos do Node.js e são utilizadas para manipulação de operações de arquivos e caminhos de diretórios, respectivamente, enquanto a biblioteca pdf-parse será nossa escolha para extrair o texto de arquivos PDF.

Este tutorial explora a criação de um programa em Node.js para a organização automatizada de arquivos em pastas com base em palavras-chave. Tal abordagem oferece uma solução prática e eficaz para a organização de documentos, resultando em uma economia considerável de tempo. Ao implementar o código no terminal, o usuário precisa apenas definir a quantidade de categorias desejadas e as palavras-chave correspondentes. Dessa forma, o processo de categorização e organização dos arquivos PDF se torna rápido, eficiente e altamente customizável, atendendo às necessidades individuais de cada projeto.

Agora que compreendemos a importância desse tutorial e o contexto no qual ele se insere, podemos avançar com o passo a passo detalhado da implementação. Vamos explorar cada aspecto do código, desde a interação com o usuário até a categorização dos arquivos PDF e sua organização em pastas.

Prepare-se para adentrar no mundo da automação e eficiência proporcionado pelo Node.js e pela biblioteca pdf-parse!

Com as dependências instaladas, é hora da prática de implementar o código. Criaremos um script em Node.js que irá ler todos os arquivos PDF de um diretório específico, extrair os dados relevantes de cada PDF utilizando a biblioteca pdf-parse.

Dentro do código, usaremos funções assíncronas e promessas para garantir que as operações sejam executadas de forma eficiente e sem bloquear o fluxo do programa.

Passo 1: Configuração Inicial

Inicialmente, verifique se você tem o Node.js instalado em seu sistema. Caso não tenha, você pode baixá-los e instalá-los a partir dos sites oficiais:

• Node.js: https://nodejs.org/

Após ter o Node.js instalado, crie uma pasta chamada “currículos” no mesmo diretório em que será colocado o script.

Dentro da pasta “currículos”, insira os arquivos PDF que contenham as informações de currículos que você irá utilizar.

Em seguida, execute o seguinte comando para criar o arquivo package.json e instalar as dependências necessárias:

Passo 2: Instalação de Depedências

Agora, instalaremos as bibliotecas necessárias. Execute o comando abaixo no terminal:

Explicação das dependências:

• fs: Módulo nativo do Node.js para lidar com operações de arquivo.
• path: Módulo nativo do Node.js para manipular caminhos de arquivos e diretórios.
• readline: Módulo nativo do Node.js que facilita a leitura de entradas do usuário a partir da linha de comando.
• pdf-parse: Biblioteca para extrair o texto de arquivos PDF.

Passo 3: Implementação do Código

Agora, é o momento de implementar o código. Crie um arquivo chamado ‘node index.js’ e insira o seguinte código:

pdfsDirectory: É o caminho do diretório onde os arquivos PDF serão lidos. No código atual, os PDFs devem estar na pasta ./curriculos (na mesma pasta do script).

askForCategories: Essa função visa solicitar ao usuário a quantidade e os nomes das categorias que serão utilizadas para organizar os arquivos PDF.

startCategorization: Função que possui como objetivo iniciar o processo de categorização, ela chama a função anterior (aksforcategories) para obter as categorias determinadas pelo usuário, e em seguida chama a função “readAndCategorizePDFsFromDirectory” para categorizar os arquivos PDF.

readPDF: Função responsável por ler o conteúdo de um arquivo PDF e retornar uma promessa que contém os dados do PDF analisado.

readAndCategorizePDFsFromDirectory: Esta função tem como finalidade ler todos os arquivos PDF do diretório e categorizá-los, com base nas palavras chave encontradas em seus conteúdos.

Passo 4: Executando o Programa

Agora, abra o terminal e digite o seguinte comando:

“node index.js”

Para ilustrar a execução do programa e categorização dos currículos, solicitei ao programa que separasse os arquivos selecionados em quatro categorias: front end, back end, full stack e css, e o que não se enquadra nessas palavras chaves, será separado em uma pasta denominada como outros:

Após a categorização, realizada de forma interativa com o usuário pelo terminal, o programa exibe como ficou a organização dos currículos nas pastas, atendendo aos critérios solicitados pelo usuário:

Dessa forma, conforme o programa identificou as palavras-chave solicitadas, após categorizar os arquivos PDF, foi criada uma pasta referente às categorias, e o que não se enquadra nos requisitos solicitados, foi movido para a pasta chamada de “outros”. Utilizando esse código, você pode aprimorar e personalizar os arquivos conforme suas demandas.

Conclusão

Neste tutorial, o objetivo foi mostrar uma solução eficaz para quem procura automatizar processos de organização de arquivos no formato PDF, com a criação de um programa em Node.js para automatizar arquivos em pastas com base em palavras-chave.

No decorrer deste tutorial, exploramos um cenário prático em que a automação de tarefas se mostrou uma solução poderosa e eficiente. Ao utilizar a linguagem de programação Node.js e a biblioteca pdf-parse, fomos capazes de desenvolver um programa capaz de extrair informações relevantes de arquivos PDF e categorizá-los de acordo com palavras-chave específicas. Esse processo não apenas simplificou a organização de documentos, mas também economizou um tempo valioso que poderia ser direcionado para tarefas mais estratégicas.

O tutorial começou com uma introdução abordando a importância dos arquivos PDF no mundo digital e os desafios de manipulá-los. Discutimos a preparação do ambiente de desenvolvimento, incluindo a instalação do Node.js e das bibliotecas necessárias. Em seguida, detalhamos o código passo a passo, explicando cada função e componente envolvido. A introdução da interação com o usuário por meio do readline trouxe uma experiência mais amigável e personalizada à aplicação.

O ponto central do tutorial foi a criação da função que lê e categoriza os arquivos PDF com base nas palavras-chave definidas pelo usuário. A automação desse processo resultou em um ganho significativo de eficiência, reduzindo a necessidade de intervenção manual repetitiva. Essa abordagem pode ser aplicada em diversos cenários, desde a organização de currículos até a classificação de documentos comerciais.

Ao final, discutimos brevemente o conceito de automação, ressaltando sua relevância em otimizar tarefas rotineiras e liberar recursos para atividades mais estratégicas e criativas. Através deste tutorial, você não apenas aprendeu a criar um programa funcional, mas também compreendeu a importância de automatizar tarefas em diversos contextos.

Em suma, a automação é uma ferramenta valiosa no mundo moderno, e este tutorial ofereceu um exemplo prático de como ela pode ser implementada por meio da programação. Esperamos que você tenha adquirido conhecimentos úteis e inspiração para explorar ainda mais as possibilidades da automação em suas atividades diárias e projetos futuros.

O processo de organização de arquivos que é feito de forma manual pode ser extremamente demorado, especialmente quando há uma quantidade exorbitante de documentos para categorizar e organizar por pastas. Assim, ao implementar o código desenvolvido e apresentado neste tutorial, esse processo pode ser simplificado, com um comando no terminal, na qual os usuários precisarão apenas fornecer a quantidade de categorias desejadas e as palavras-chave que serão usadas para categorizar os arquivos.

Essa abordagem traz inúmeros benefícios, como a redução de erros e otimização do fluxo de trabalho, além da melhor gerência do nosso tempo, ao possibilitar que o programa automatize tarefas repetitivas e propensas a erros, dessa forma o usuário pode se concentrar em tarefas mais criativas e estratégicas.

Portanto, se você está buscando otimizar a organização de documentos, este tutorial pode ser a solução prática e acessível. Agora, você possui em mãos um poderoso instrumento para automatizar a categorização de arquivos PDF com base em critérios definidos, visando economizar tempo e tornar a atividade mais eficiente.

A economia de tempo obtida por meio dessa automação é inestimável, pois libera o usuário para utilizar seu tempo em atividades mais produtivas, e a medida que nos aprofundamos na programação e desenvolvemos soluções mais complexas, o conhecimento adquirido aqui servirá como base sólida para futuras empreitadas.

No contexto do desenvolvimento de software, a automatização desempenha um papel vital, melhora a qualidade do código e acelera o ciclo de desenvolvimento. Muitas tarefas podem ser automatizadas e amplamente utilizadas em atividades rotineiras do dia a dia.

Por fim, você pode prosseguir com confiança, sabendo que automação tem um poderoso potencial em produtividade e aplicabilidade em vários contexto, espero que esse tutorial tenha inspirado você a explorar mais a fundo as capacidades do node.js e a criar soluções inteligentes para desafios do mundo real.

Referência Bibliográfica

• Documentação oficial do Node.js: https://nodejs.org/
• Documentação da biblioteca pdf-parse: https://www.npmjs.com/package/pdf-parse
• Documentação da biblioteca fs (Node.js): https://nodejs.org/api/fs.html
• Documentação da biblioteca path (Node.js): https://nodejs.org/api/path.html
• Documentação da biblioteca readline (Node.js): https://nodejs.org/api/readline.html

Na parte 1 desse módulo aprendemos a como criar uma estrutura funcional com React Router DOM. Nessa segunda parte do artigo iremos aprender a como usar os Parâmetros da URL junto com React Router. Para isso, iremos dar continuidade ao projeto que estamos utilizando desde a parte 1 do artigo, se você chegou aqui de paraquedas e quer pegar essa explicação desde o início acesse esse link.

O que são os parâmetros da URL?

Os parâmetros da URL se referem a valores variáveis que podem ser incluídos na própria URL para representar informações específicas, como IDs, nomes ou outros dados relevantes para a página ou componente que está sendo renderizado. Os parâmetros da URL são uma parte essencial do roteamento dinâmico, permitindo que você crie páginas reutilizáveis e dinâmicas que exibem informações diferentes com base nos valores fornecidos na URL.

Vamos ver isso na prática!

Configurando os parâmetros da URL:

Para que possamos utilizar esse recurso será necessário fazer a configuração básica dele. Vamos supor que o usuário está na aba de produtos e ele quer ver dados de um jogo X, é justamente aí que entra esse recurso.

No arquivo router.jsx vamos adicionar uma nova rota. Essa nova rota terá como caminho o /products mas além disso, quando o usuário clicar no produto a rota deverá ser acessada por meio de algum parâmetro. Esse parâmetro deve ser um nome exclusivo, isto é, um ID. Para criar esse parâmetro é bem simples, basta passar no caminho /products/ o parâmetro :productId. E atrelado a esse caminho o elemento que será carregado, isto é, a tela de exibição. Logo, o arquivo router.jsx ficará assim:

Feito isso, é necessário criar a page Product, dentro da pasta page. Dentro da pasta page, crie o arquivo Product.jsx e dentro dele adicione o conteúdo:

As pastas e arquivos devem estar assim até o momento:

Ajustando redirecionamento para os parâmetros da URL:

Agora que fizemos a configuração inicial da página, nada mais justo do que cada produto acessar suas respectivas características. Para isso vamos adicionar o componente Link que o React Router DOM disponibiliza, no arquivo Products.jsx:

Agora, você pode fazer um teste. Acessando a aba Produtos e clicando no botão ver, vai ser redirecionado para a página padrão que criamos (a Product) e na URL estará /product/1 (se você acessar o primeiro produto estará 1, caso contrário estará qualquer outro valor).

Página de Produtos:

Após clicar para ver o produto:

Veja que os parâmetros da URL foram alterados e o conteúdo também!

Renderizando os dados de cada produto de forma dinâmica

Criamos uma página Product, que por padrão tem apenas um Link e um título, mas não é isso que queremos mostrar para o usuário, o que queremos mostrar são as informações gerais sobre o produto que ele está acessando.

Para isso, também é bem simples. Basta utilizarmos um hook do React Router DOM: useParams(). Que é um hook que serve justamente para utilizarmos os parâmetros da URL e assim seja possível capturar o valor, nesse caso, o ID do produto que o usuário está acessando e renderizar na tela as informações do produto que ele deseja visualizar!

OBSERVAÇÃO IMPORTANTE: O hook useParams retorna um objeto. Portanto, você pode acessar esse valor do parâmetro por meio da sintaxe nomeDaVariavel.nomeDoParâmetro ou pode desestruturar esse objeto, já capturando o valor do parâmetro (vamos utilizar esse método nesse artigo).

Logo, no arquivo Product.jsx ficará assim:

Agora, teremos que importar todos os produtos do nosso banco de dados fictício e procurar pelo produto que o usuário está acessando usando o método find() na lista de produtos:

OBSERVAÇÃO IMPORTANTE: no método find() utilizei antes de productId o sinal de “+” para converter de forma simples o tipo do valor de string para number. Caso essa conversão não fosse feita, daria um erro. Você pode testar retirando o sinal de “+”.

Por fim, vamos renderizar os dados do produto:

Analisando o código no ambiente de produção

Agora, podemos ver como está ficando o nosso projeto no navegador! Ao tentar ver os detalhes de qualquer produto deve carregar todas as suas informações dessa forma:

Se o seu projeto está dando algum erro, recomendo que o analise cuidadosamente e qualquer coisa basta acessar o repositório do projeto no Github!

Finalização

Em conclusão, neste artigo exploramos a importância e a utilidade dos parâmetros da URL no React Router DOM. Aprendemos como utilizar os parâmetros da URL para criar páginas dinâmicas e reutilizáveis, permitindo que nossos aplicativos renderizem conteúdo específico com base nas informações presentes na URL. Vimos como capturar esses parâmetros usando o useParams() hook e como utilizá-los para buscar e exibir dados relevantes.

No próximo artigo, darei continuidade a esta série, expandindo nosso conhecimento para lidar com um aspecto crucial do desenvolvimento de aplicações usando o React Router DOM: o tratamento de erros. Abordarei como criar páginas de erro personalizadas, como lidar com situações em que rotas não correspondentes são acessadas e como aprimorar a experiência do usuário ao enfrentar problemas de navegação.

Gostaria de agradecer por acompanhar este artigo e pela dedicação em aprender mais sobre o React Router DOM e suas funcionalidades. Espero vê-lo na terceira e última parte desta série, onde continuaremos a aprofundar nosso entendimento e aprimorar nossas habilidades de desenvolvimento com o React Router DOM. Até lá, continue explorando, codificando e expandindo seus horizontes no mundo do desenvolvimento web com React.

A qualidade do software é de fato uma "linha tênue" que pode definir se um produto será bem-sucedido ou não, pois software de baixa qualidade pode resultar em problemas de usabilidade, segurança e desempenho, afetando a satisfação dos usuários e a reputação da empresa.

Duas funções essenciais nesse processo são as de um QA (Analista de Qualidade de Software) e de um Testador de Software.  E embora muitas vezes esses termos sejam usados de forma intercambiável, eles desempenham papéis distintos e complementares.

Neste artigo, exploraremos alguns aspectos sobre cada um desses papéis.

1. Escopo de Atuação

O papel do Testador de Software é mais focado na execução de testes para identificar defeitos e bugs no software. Eles seguem planos de teste predefinidos e reportam os resultados. Em outro viés, o Analista de Qualidade de Software (QA) tem um escopo mais amplo. Eles definem as estratégias gerais de qualidade, coordenam os processos e trabalham para melhorar a qualidade geral do desenvolvimento de software.

2. Visão Estratégica vs. Execução Tática

Enquanto os Testadores executam testes conforme diretrizes específicas, os QAs adotam uma abordagem estratégica. Eles estabelecem processos de garantia de qualidade, como a definição de padrões de teste, a criação de métricas de qualidade e a implementação de melhores práticas.

3. Envolvimento no Ciclo de Vida do Software

Os Testadores de Software geralmente estão mais ativos na fase de testes do ciclo de vida do software. Eles realizam testes específicos em diferentes estágios do desenvolvimento. Por outro lado, os QAs estão envolvidos desde o início do projeto. Eles contribuem para a definição de requisitos de qualidade, participam de revisões de design e ajudam a moldar o processo geral de desenvolvimento.

4. Comunicação e Colaboração

Os Testadores de Software interagem principalmente com os desenvolvedores, comunicando os problemas identificados nos testes. QAs, por outro lado, colaboram com toda a equipe, incluindo desenvolvedores, gerentes de projeto e partes interessadas. Sua função envolve uma comunicação eficaz para garantir que as expectativas de qualidade sejam compreendidas por todos os envolvidos.

5. Habilidades Necessárias

Enquanto ambas as funções exigem habilidades técnicas, os Testadores de Software precisam ser especialmente bons em executar procedimentos de teste e relatar resultados de maneira clara. Os QAs precisam de uma gama mais ampla de habilidades, incluindo gerenciamento de processos, análise de requisitos e habilidades interpessoais fortes.

6. Automação de Testes

A automação de testes é uma área em crescimento dentro do desenvolvimento de software. Embora os Testadores possam se envolver na automação de testes, essa responsabilidade muitas vezes recai sobre os QAs, que estão mais envolvidos na definição de estratégias de automação e na seleção de ferramentas apropriadas.

Em síntese, os QAs e os Testadores de Software desempenham papéis complementares e vitais na busca pela excelência do software. Enquanto os Testadores são os olhos que identificam as imperfeições, os QAs são os alicerces que sustentam os padrões de qualidade da organização. Nesse equilíbrio, a colaboração entre esses dois pilares emerge como a força motriz por trás do sucesso de um software de alto padrão. Juntos, eles moldam a qualidade que não apenas atende, mas supera as expectativas.

Referências

Pressman, Roger S. Engenharia de software : uma abordagem profissional [recurso eletrônico] / Roger S. Pressman, Bruce R. Maxim ; [tradução: João Eduardo Nóbrega Tortello ; revisão técnica: Reginaldo Arakaki, Julio Arakaki, Renato Manzan de Andrade]. – 8. ed. – Porto Alegre : AMGH, 2016.

Neste artigo, você aprenderá um pouco mais sobre o conceito de funções na linguagem Javascript e também conhecerá as principais funções utilizadas no desenvolvimento web.

Javascript

Javascript é uma linguagem de programação muito utilizada para o desenvolvimento de aplicações web, pois, permite a criação de componentes dinâmicos e interativos, que tornam as páginas intuitivas e muito atrativas para os usuários.

Curiosidade

Um teste interessante para se fazer e visualizar diretamente os efeitos do Javascript em um site é desativá-lo para sua visualização. É possível fazer isso pelo navegador Chrome seguindo estas etapas: insira no seu navegador Chrome://settings/content/javascript. Selecione a opção “Não permitir que os sites usem Javascript”. Acesse um site (um dica: google.com) e observe os efeitos da página sem a aplicação do Javascript. No Google, repare especialmente na barra de opções na qual estão dispostos os itens “Imagens”, “Vídeos”, etc.

Detalhe importante: ao fazer esse teste, você apenas desabilita a visualização para você e é possível retornar ao normal refazendo essas etapas e selecionando de volta a permissão para a utilização do Javascript. As páginas não sofrem nenhum prejuízo, pois, essa alteração somente reflete no seu navegador.

Funções

“Uma função é um bloco de código JavaScript definido uma vez, mas que pode ser executado (ou chamado) qualquer número de vezes”. Essa definição foi dada por David Flanagan no famoso livro JavaScript - O Guia Definitivo e resume muito bem o que são as funções na linguagem. Elas são estruturas extremamente úteis na rotina dos desenvolvedores, pois, possibilitam a criação de códigos mais limpos, com trechos que podem ser reaproveitados. Além disso, ao utilizar funções é minimizada a chance de erros na manipulação dos trechos, pois, ao alterar uma função, isto repercutirá em todos os locais onde ela for utilizada. Uma característica importantíssima das funções é que elas possuem parâmetros que funcionam como variáveis locais. Os valores destes parâmetros são passados justamente quando as funções são chamadas.

Definições

Functions declaration (declaração de função): a declaração de função é realizada a partir do uso da palavra function seguida pelos símbolos (), dentro dos quais são inseridos os parâmetros, e pelas chaves {}, que englobam as instruções da função. Confira o exemplo:

No exemplo acima, a função multiplicarNumero recebe a e b como parâmetros e retorna o valor da operação de multiplicação dos dois valores. Repare que não passamos os valores em si, pois devemos inseri-los ao chamar a função, conforme o código abaixo:

Functions expression (expressão de função): as funções também podem ser criadas por meio de uma expressão e são úteis especialmente quando o objetivo é passar uma função como argumento para outra função. Elas podem ser anônimas ou receberem um nome, conforme os exemplos abaixo:

Arrow Functions (função de flecha): esse tipo de sintaxe serve para escrever funções de formas reduzidas, mas com o mesmo propósito e resultado das funções normais. O objetivo é simplificar e tornar o código mais limpo. Confira um exemplo de arrow function:

Na arrow function, não é utilizada a palavra function e sim o símbolo =>, que remete justamente ao nome do tipo de função.

Functions constructor (função construtora): estas funções são definidas, basicamente, da mesma forma que as outras declarações ou expressões. Entretanto, existem algumas diferenças importantes. Geralmente, estas funções são nomeadas com palavras que possuem a primeira letra maiúscula e, ao serem invocadas, necessitam do uso da palavra new. Repare no exemplo abaixo:

Na constante user, estamos criando um novo usuário ao invocar a função Usuario, passando o nome Luiza como parâmetro.

Generator Functions (Função geradora): as funções geradoras possuem o símbolo * após a palavra function e podem ser pausadas e retomadas durante a execução. Confira o exemplo, que iremos detalhar abaixo:

Observe que dentro da função usamos a palavra yield que tem o objetivo de pausar a execução e retornar um valor. Quando utilizamos o gerador.next(), a função é executada até encontrar a próxima instrução, ou seja, o próximo yield ou até finalizar. Repare no nosso exemplo que adicionamos quatro console.log(gerador.next()). Até rodar a quarta vez, o valor estava sendo retornado conforme previsto na função e o done, que representaria o encerramento da função, como false. Quando chegamos ao fim, o valor retorna como undefined e o done como true, sinalizando que a função foi concluída.

Métodos

Os métodos são funções prontas e utilizadas para realizar operações específicas em diversos tipos de dados, tais como strings, objetos ou arrays. Confira abaixo alguns exemplos, com seus conceitos e exemplos:

Neste artigo, você conheceu um pouco mais sobre as funções, seus conceitos e definições, na linguagem JavaScript.

Bons estudos!

Durante a construção de um software, a modelagem é uma das principais etapas executadas. Como o software trata-se de uma entidade abstrata, a visualização do sistema a ser construído é fundamental aos desenvolvedores. A Modelagem UML (Unified Modeling Language) é uma linguagem visual utilizada para representar, especificar, construir e documentar sistemas de software e seus processos. A UML dispõe de um conjunto de diagramas e notações que permitem compreender melhor a estrutura, interações e requisitos do sistema, além de ser possível avaliar a qualidade do resultado e reduzir as incertezas do processo.

Neste artigo, vamos abordar sobre os tipos de diagramas da UML e seus objetivos de uso.

Tipos de diagramas

A UML apresenta dois tipos de diagramas: os Diagramas Estruturais e os Diagramas Comportamentais. A figura abaixo apresenta a árvore de tipos e subtipos de diagramas.

A UML nasceu da união de três metodologias de modelagem: o método de Booch, o método OMT (Object Modeling Technique) de Jacobson e o método OOSE (Object-Oriented Software Engineering) de Rumbaugh. Atualmente, ela encontra-se na versão 2.5.1 e sua documentação oficial pode ser encontrada em seu site oficial.

A UML apresenta uma variedade de tipos de diagramas, que podem ser utilizados isoladamente ou complementando entre si. Assim, é possível analisar as múltiplas visões do sistema, observando seus diferentes aspectos.

A seguir, vamos falar um pouco de cada um deles.

Diagramas Estruturais

Os diagramas estruturais focam na representação da estrutura estática de um sistema, ou seja, como os elementos do sistema estão organizados e relacionados entre si. A seguir, temos os tipos de diagramas estruturais.

Diagrama de Classe

O principal objetivo é visualizar as classes que irão compor o sistema em questão e demonstrar a dinâmica da relação que existe entre elas. Além das classes, também seus atributos e métodos. Este diagrama serve de apoio para a construção dos demais diagramas da UML. A seguir, temos um exemplo:

Na figura acima temos um exemplo de um sistema bancário. Na UML, uma classe apresenta três informações, que estão representadas como um retângulo com três divisões:

• Primeiro retângulo: nome da classe, ContaCorrente;
• Segundo retângulo: os atributos e tipos de dados da classe;
• Terceiro retângulo: os métodos (ações) da classe.

Diagrama de Objetos

Representa uma visão estática de um conjunto de objetos e suas associações em um momento específico. Tem como objetivo fornecer uma visão dos valores armazenados pelos objetos das classes, definidas no diagrama de classes. Veja o exemplo abaixo:

Neste exemplo, temos o vínculo entre o objeto pessoaFis1 da classe PessoaFisica e o objeto corrente1 da classe ContaCorrente. Para cada uma das representações dos objetos, tem-se a listagem dos seus respectivos atributos. Assim, infere-se que uma pessoa física possui uma conta corrente.

Diagrama de Componentes

Exibe os componentes do sistema e suas dependências, incluindo bibliotecas, módulos e outras partes do software. Em outras palavras, exibe o relacionamento entre os diferentes componentes de um sistema.

Diagrama de Pacotes

Organiza os elementos do sistema em grupos lógicos, denominados pacotes, demonstrando a dependência entre eles e ajudando a estruturar e modularizar o sistema. Pode ser utilizado, por exemplo, para modelar divisões da arquitetura de uma linguagem, simplificando diagramas de classe complexos.

O exemplo acima apresenta o pacote chamado Sistema de controle Bancário, o qual engloba diversos elementos, como as classes Pessoa e Conta e suas respectivas classes-filhas.

Diagrama de Implantação

O diagrama de implantação apresenta um mapeamento da relação entre os componentes de software e sua infraestrutura (hardware). Ele ajuda na visualização dos processadores, nós e dispositivos vinculados.

Diagramas Comportamentais

Os diagramas comportamentais são usados para descrever o comportamento dinâmico do sistema, ou seja, como os componentes interagem, se comportam e trocam informações ao longo do tempo. Eles ajudam a modelar os aspectos funcionais e interativos do sistema. Veja os tipos de diagramas comportamentais a seguir.

Diagrama de Casos de Uso

Este diagrama demonstra o comportamento externo do sistema. A partir da perspectiva do usuário, mostra as interações entre atores (usuários) e os casos de uso do sistema, focando nos cenários de interação. É utilizado geralmente no início da modelagem, durante o processo de levantamento e análise de requisitos. Na figura abaixo temos um exemplo deste diagrama.

Em um sistema de vendas de uma livraria, temos os atores Vendedor e Gerente, os quais são funcionários e podem realizar a ação de vender livros.

Diagrama de Atividades

Este diagrama modela o fluxo de atividades e ações dentro de um processo ou função, mostrando estados, transições e decisões. Fornece uma visualização do comportamento de um sistema, descrevendo a sequência de ações em um processo. Pode ser aplicado, por exemplo, na descrição de computação procedural, ou na modelagem organizacional para processos de negócios.

Diagrama de Estado

Descreve os diferentes estados pelos quais um objeto pode passar e as transições entre esses estados.

Diagrama de Interação

O objetivo deste diagrama é fornecer uma visão geral do controle de fluxo, mostrando como os objetos interagem uns com os outros. Nele, temos os subtipos:

• Diagrama da Visão Geral da Interação: permite ter um visão geral do fluxo de controle de uma interação para outra, bem como o fluxo de atividade de um diagrama para outro.
  
• Diagrama de Comunicação: descreve as relações e interações entre vários objetos de software.
  
• Diagrama de Tempo: representa um conjunto de estados de um objeto ou sistema ao longo do tempo, mostrando eventos e transições temporais. Com ele, é possível visualizar o fluxo em vários instantes do tempo.
  
• Diagrama de Sequência: representa a sequência de interações entre objetos ao longo do tempo, enfatizando quais mensagens devem ser disparadas e em qual ordem. Este diagrama baseia-se no diagrama de caso de uso, já que um caso de uso, geralmente, refere-se a um processo disparado por um ator. Veja o diagrama a seguir, que representa uma operação em um sistema bancário.
  

No exemplo acima, temos o fluxo e ordem das mensagens disparadas durante a operação de emissão de extrato para uma conta corrente. A partir da inserção do cartão, ocorre:

• Verificação da conta;
• Solicitação da senha e verificação da senha;
• Seleção da opção desejada do sistema;
• Geração e emissão do extrato bancário.

Conclusão

Como vimos, a UML é uma linguagem visual padrão para modelagem de sistemas de software. Dentre suas diversas vantagens, podemos destacar o processo de facilitar a comunicação entre as equipes de desenvolvimento, permitindo uma apresentação mais clara e compreensível do software projetado. Além disso, possibilita documentar os requisitos, identificar problemas e elaborar soluções. O melhor entendimento do projeto e a detecção de erros antecipadamente, permitem desenvolver um produto mais eficiente.

Dando continuidade a nossa série de artigos sobre como fazer um sistema de cadastro simples em Node.js, utilizando MongoDB e ExpressJS, desenvolvendo o CRUD.

Nesta quarta e última parte, iremos ver um conceito importante quando se trata da construção de interfaces, que é a parte de modularização da página, onde utilizaremos o recurso chamado partial views do EJS, que é a view engine que estamos utilizando com o framework Express js.

Para dar uma estilizada, usaremos o framework conhecido como Bootstrap, que é amplamente utilizado para dar estrutura a aplicações web mais responsivas e com boas experiências para os usuários.

O que é o Bootstrap?

Em um breve resumo, o Bootstrap é um framework front-end que nos fornece estruturas de CSS para criação de sites e aplicações responsivas de forma bem simples e rápida. Também funciona muito bem com sites para desktop e páginas de dispositivos móveis.

Como o Bootstrap é distribuído?

As 2 formas mais comuns de distribuição pelo site oficial e npm. Você também tem a opção de criar a sua própria distribuição, caso queira, utilizando o código-fonte, ou utilizando a própria rede de distribuição do Bootstrap conhecida como CDN do BootStrap. Basicamente, um CDN permite que um site da web recupere com frequência arquivos que são distribuídos publicamente usados em servidores distribuídos globalmente.

Mais a frente neste artigo, faremos a instalação para podermos dar aquela melhorada no visual da nossa aplicação.

O que são Partial Views?

Depois desse breve resumo sobre o Bootstrap, voltamos para o assunto inicial. Mas afinal,o que são essas Partial views? É bastante comum quando estamos desenvolvendo uma aplicação que existam certas partes das telas (views) que se repetem. Tendo isso em mente, todas as linguagens de programação para web possuem recursos de Partial Views, que são justamente uma modularização da interface, separando-a em “partes” da tela, construídas separadas e depois montadas em conjunto para que o usuário veja apenas o resultado final.

Nossa aplicação é bem simples e por isso possui apenas 3 views, sendo elas: index, new e error, conforme vemos abaixo:

A estrutura acima é bem básica, logo, não teria necessidade de fazer essa modularização com Partial Views, vamos abordar aqui apenas para conhecimento/entendimento, também para mostrar que é um poderoso conceito, além de tornar seu frontend mais legível e elegante, torna o desenvolvimento de novas páginas de uma forma muito mais ágil, pois aproveita os elementos genéricos criados apenas uma vez, sendo utilizado em outras telas.

Se formos até as nossas views index.ejs e new.ejs, podemos notar que em ambas existem muitas tags em comum no começo e no fim delas.

Index:

New:

Vamos começar por elas.

Partial View com EJS

O EJS possui a funcionalidade de criar partial views de forma bem fácil. Começaremos criando um arquivo top.ejs na pasta views. Top será referente ao TOPO da nossa página e nele iremos adicionar toda estrutura da parte comum que teremos em todas as views da nossa aplicação. No arquivo criado, adicione a estrutura abaixo:

No código acima, no arquivo top.ejs, podemos notar algumas variáveis JS que deverão vir do nosso backend, através do model que é passado na nossa função render do Node.js.

Em seguida, nós iremos criar um segundo arquivo dentro da pasta views, esse arquivo irá se chamar bottom.ejs, bottom será referente ao RODAPÉ e nele vamos adicionar apenas 2 linhas por enquanto:

Agora você deve estar se perguntando como fazemos para que uma view possa utilizar essas partial views que acabamos de criar. Pois bem, vamos começar indo até a nossa index.ejs e no topo do arquivo remova a parte que é repetida dentro do top.ejs e no lugar do pedaço de código excluído, use o include como demonstraremos abaixo para incluir a nossa partial view na primeira linha do arquivo, ficando da seguinte forma:

E na parte de baixo, faremos o mesmo com o bottom.ejs:

Após o processo acima, quando o arquivo HTML for ser construído para que possa ser enviado ao browser para ser renderizado, o EJS vai ler a primeira linha e entender que a parte HTML dessa linha, vem de outro arquivo, então irá até esse arquivo, copiará seu conteúdo e utilizará neste local.

Observe que com apenas esses 2 includes utilizados, temos nossa aplicação modularizada em 3 partes, top = topo, center = centro, bottom = rodapé, o que facilita a manutenção e reuso do código.

Tendo em mente que agora podemos reutilizar o nosso código, faremos as mesmas substituições no arquivo new.ejs e error.ejs para não precisarmos mais repetirmos os blocos de códigos no começo e no fim de nossos arquivos HTML. Como nossa aplicação é bem simples, não dá para notar o quanto temos de ganho, mas caso façamos aplicações maiores, os ganhos e facilitações para manutenção do nosso código fazem total diferença.

Vamos começar pelo arquivo error.ejs:

E new.ejs:

Depois de feitas as alterações acima, rode novamente sua aplicação Node como fazemos, lembre-se de subir seu banco do MongoDB também e você irá notar que tudo rodou direitinho mas que nada mudou para o usuário. Tudo é renderizado igualmente como era antes, mas tenha em vista que as alterações que fizemos, servem para tornar a nossa vida de desenvolvedor mais fácil.

O nosso próximo passo aqui será adicionar o framework de frontend que vamos utilizar e que resumi de forma breve no começo deste artigo. Você também notará como será mais fácil fazermos a “manutenção” do nosso código após essa modularização.

Adicionando o Bootstrap ao projeto

Vamos começar adicionando as duas dependências do Bootstrap que podem ser obtidas neste link do site oficial. A primeira delas é a de CSS e deve ser adicionada no topo do nosso arquivo top.ejs, substituindo a chama antiga do CSS que estava no arquivo:

Como adicionamos o código acima no top.ejs, agora todas as telas que utilizam essa partial view vão estar com o CSS do Bootstrap adicionada a elas. Note a produtividade que tivemos, se pararmos para pensar, imaginem uma aplicação com 12 telas e você tendo que mexer de uma por uma para fazer a manutenção do código?

Observe que adicionei duas meta-tags como o que a página do Bootstrap no link acima sugere, isso garante maior compatibilidade com os recursos que o framework oferece e também tem a responsividade em dispositivos móveis.

Nosso próximo arquivo que será modificado será o bottom.ejs. Iremos agora adicionar o script JS necessário para o funcionamento do Bootstrap, ele será adicionado logo antes da tag </body>. Ficando da seguinte forma:

Só com essas leves mudanças que fizemos, rode a aplicação e veja os novos efeitos visuais da nossa aplicação.

Mas sempre podemos melhorar nossa aplicação de alguma forma, vamos agora usar alguns dos “poderes” do Bootstrap para que façamos algumas alterações na nossa estrutura, como também usar algumas classes CSS definidas pelo Bootstrap.

Nosso primeiro passo, será começar definindo uma div class container que vai englobar toda a parte de conteúdo do body das nossas telas. Para fazermos isso, basta que adicionemos o conjunto de tags div que mostrarei abaixo, mas basicamente você terá que abrir a div no top.ejs e fechar no bottom.ejs de modo que ambas fiquem dentro do body.

top.ejs:

Observe que mudamos apenas uma linha, logo acima da tag H1, bem no fim do arquivo top.ejs.

bottom.ejs:

Note que no arquivo bottom.ejs também mudamos apenas uma linha que fica bem no começo do arquivo.

Após essa mudança nos arquivos já teremos uma mudança mais perceptível nas páginas já existentes, que terão uma margem maior e estarão centralizadas de outra forma.

A div container que criamos faz a sua página funcionar em um grid-system de 12 colunas, ou seja, o Bootstrap permite que possamos organizar os conteúdos de nossas páginas em 12 blocos que possuem tamanhos iguais. Se você organizar direitinho utilizando o espaço que foi disponibilizado, a sua aplicação web será responsiva, alterando seus conteúdos conforme a tela do aparelho que estiver acessando a mesma precisar.

Espero que essa série de artigos possam ajudar vocês a terem uma noção melhor de como construir uma aplicação web básica utilizando Node.JS, MongoDB, ExpressJS e EJS. Tendo em vista que essa aplicação pode ser usada em vários tipos de serviço diferentes, também aconselho se aprofundar mais um pouco na parte de Bootstrap, pois, o frontend de fato não foi desenvolvido aqui neste artigo, trouxe apenas uma introdução e mostrei como adicionar o Bootstrap na sua aplicação.

Em um próximo artigo, farei a parte de estilização da nossa aplicação para abrir um leque maior de possibilidades e melhor explicar como o Bootstrap pode ser útil realmente. Irei criar o repositório com os código-fonte dessa série que concluímos aqui e disponibilizarei o link para o melhor acompanhamento do conteúdo.

Também trarei esse conteúdo referente ao CRUD em uma outra linguagem na nossa próxima série de artigos, a linguagem JAVA.