Engenharia de software na era da IA: trabalhando com legado, escala e múltiplos serviços

Entendendo o projeto legado - Apresentação

Apresentando o instrutor e o curso

Olá, bem-vindo a mais um curso aqui na Alura. Meu nome é Charleston Josué Campos.

Audiodescrição: Charleston é um homem negro, com cabelo cacheado e barba longa. Ele está entusiasmado para realizar implementações em um projeto legado utilizando IA.

Introduzindo o projeto RotaLog e suas funcionalidades

Neste curso, vamos aplicar e utilizar o Cloud Code junto ao projeto legado chamado RotaLog. O RotaLog é um projeto construído com muita dedicação pelas pessoas desenvolvedoras que trabalharam nele. Podemos visualizar uma parte dessa aplicação, que, no front-end, está dividida em duas partes.

Uma parte permite verificar e visualizar os pedidos que saem de um local determinado e se chegaram ao seu destinatário final. Chamamos essa parte da aplicação de rastreamento. A outra parte é o painel administrativo, onde podemos consultar e verificar cada veículo da frota, identificar se necessita de manutenção específica e saber exatamente o estado atual de cada veículo.

Explorando o uso de inteligência artificial no projeto

Estamos muito animados para apresentar o Cloud Code à aplicação RotaLog e mostrar como a inteligência artificial pode nos ajudar, proporcionando diversos recursos para entregas mais rápidas e consistentes. Além disso, teremos um assistente virtual para colaborar na construção de novas funcionalidades e refatorações em um projeto legado.

Pedimos que prestem bastante atenção, pois nosso foco não será a estética tecnológica aplicada no RotaLog, mas sim como a inteligência artificial pode nos auxiliar no desenvolvimento de novas funcionalidades e refatorações nessas aplicações. Embora a estética tecnológica não seja nosso foco, estamos trabalhando com diversas tecnologias, como Java, .NET, JavaScript com Node.js e alguns outros frameworks de JavaScript dentro desse ecossistema.

Preparando-se para o curso

Portanto, temos várias tecnologias e linguagens, e veremos como a inteligência artificial pode nos ajudar a criar funcionalidades, adicionar testes e verificar se tudo está funcionando perfeitamente. Isso é exatamente o que exploraremos ao longo deste curso.

Preparem-se, peguem um café, e nos encontramos no próximo vídeo. Até breve!

Entendendo o projeto legado - Conhecendo o contexto do projeto

Introduzindo o uso de IA em projetos legados

Olá, é bom estarmos aqui novamente para aprofundar mais no uso de IA no nosso dia a dia como pessoas desenvolvedoras. Neste curso, vamos trabalhar com IA em um projeto legado, algo que normalmente enfrentamos quando estamos codificando em um projeto sobre o qual não temos muito domínio. Frequentemente, precisamos entender um projeto específico rapidamente, pois a última pessoa que trabalhou nele não conseguiu documentá-lo a tempo, e a única documentação existente é o próprio código. Isso torna o processo mais desafiador.

Vamos utilizar IA nesse contexto, onde é mais complexo entender o que precisa ser feito sem ajuda. A IA nos auxiliará a compreender o projeto, implementar novas funcionalidades e refatorar partes do código onde considerarmos necessário, facilitando o trabalho para a próxima pessoa desenvolvedora que assumir o projeto.

Explorando o projeto RotaLog

Quando falamos do mapeamento do legado, é crucial entendermos como o projeto funciona. Vamos trabalhar com um projeto chamado RotaLog, que permite rastrear um pedido realizado através de nossa frota de veículos, como vans, carros e caminhões. Com vários sistemas integrados, podemos identificar se um pacote está próximo de ser entregue ou se um veículo precisa de manutenção. Esse é o RotaLog, e é nele que vamos trabalhar.

Ao descrever o que o RotaLog faz, já podemos perceber sua complexidade. Temos vários cenários que exigem integrações entre sistemas, ou tudo pode estar em um único sistema, no clássico monolito. No entanto, neste caso, já está dividido em microserviços, o que pode facilitar ou não, dependendo da complexidade interna. Entender o projeto, o contexto e o que cada API faz é essencial para começarmos a trabalhar na aplicação, fazer sua manutenção e adicionar novas funcionalidades.

Preparando a IA para o projeto

É importante que a IA entregue o que esperamos. Não adianta delegar algo à IA sem sabermos o que queremos. Precisamos entender o que queremos antes de delegar a execução à IA. Após entender o projeto, devemos ensinar à IA o que ela deve fazer, fornecendo o contexto do projeto e as funcionalidades a serem implementadas, seja uma nova funcionalidade ou uma refatoração. Por fim, realizamos a execução, onde a IA desempenha boa parte do trabalho, e nós atuamos como revisores, verificando se a IA está entregando o que esperamos.

Detalhando a arquitetura do RotaLog

Agora, vamos entrar mais no contexto do projeto. Mencionamos que trabalhamos com um sistema chamado RotaLog, que foi dividido em microserviços e possui a parte da frota. No lado dos microserviços do back-end, temos uma API chamada API de frotas, desenvolvida em Java. Embora funcional, ela apresenta algumas inconsistências que veremos nos próximos vídeos e precisa de cuidados e refatoração. Também temos uma API de entregas, feita em Node.js, que apresenta certa desorganização por não seguir um padrão ou usar um framework específico, o que dificulta o trabalho quando não temos esse contexto.

Temos a API de notificações, que é uma API desenvolvida em .NET e tem a responsabilidade de enviar notificações aos usuários, informando que o pacote está chegando ou que foi entregue. No lado do front-end, temos o painel administrativo, que é feito em Angular, e a parte de rastreamento, que é feita em React. Portanto, utilizamos vários frameworks e linguagens em um único projeto. Isso soa familiar, pois é uma situação típica encontrada no mercado de trabalho: diversos idiomas, vários frameworks e a responsabilidade é nossa. Recebemos uma grande responsabilidade, muitas vezes sem muito contexto, e precisamos trabalhar para entregar resultados.

Utilizando IA para gerenciar o projeto

Para isso, vamos utilizar IA. Para entender como o projeto está organizado, temos a camada de usuário, que é basicamente o front-end, com a parte de back-office feita em Angular e a parte de rastreamento em React. Nos microserviços, temos as APIs de frotas, entregas e notificações. Também temos bibliotecas compartilhadas no contexto do front-end, para gerenciar melhor e compartilhar componentes entre Angular e React. Para gerenciar o front-end, utilizamos o NX, um framework para trabalhar com monorepos. O uso do monorepo facilita a gestão das bibliotecas e componentes compartilhados, permitindo um único build para facilitar a entrega dos artefatos em produção. Por isso, escolhemos o uso do NX neste contexto.

Considerações sobre o uso de ferramentas e finalizando a introdução

É importante entender que, ao executar um prompt, o resultado pode ser diferente do que mostramos na aula. Vamos utilizar o Cloud Code, mas se outra ferramenta for usada, o resultado pode variar. Precisamos analisar cuidadosamente para verificar se o resultado está dentro do esperado. Mesmo usando Cloud Code, o resultado pode ser diferente devido às probabilidades envolvidas, mas isso não significa que esteja errado. Pode ser necessário ajustar para que o resultado fique igual ao que estamos vendo.

Para finalizar, vamos mostrar o VS Code para entender a estrutura de diretórios e como trabalharemos neste curso. Com o VS Code aberto, podemos visualizar as pastas de cada projeto, dos microserviços, do back-end e do que está dentro do front-end com NX. Temos esses repositórios e um repositório chamado Workspace, onde podemos executar tudo o que precisamos, incluindo contêineres Docker e scripts de banco de dados para cada projeto. Entraremos em mais detalhes nos próximos vídeos. Não se preocupe, vamos explorar cada um desses projetos em detalhes. Nos vemos lá.

Entendendo o projeto legado - Conhecendo o backend do Rotalog

Introduzindo a estrutura do back-end

Agora que já entendemos como estão divididos os microserviços e a parte do front-end do RotaLog, vamos nos aprofundar e compreender melhor a estrutura do back-end. Vamos focar na API de entregas, notificações e API de frotas, que são os três microserviços mencionados no vídeo anterior.

Estamos com o VS Code aberto e, a princípio, vamos ignorar a pasta de front-end e de workspace, concentrando-nos apenas nas três primeiras pastas. Aumentamos o zoom para melhorar a visualização. Temos a API de entregas, desenvolvida com Node.js, que não está organizada da melhor forma possível. A estrutura está um pouco desordenada, sem seguir um padrão de mercado, o que pode gerar confusão e dificuldades. Existem outros problemas, mas no curso vamos implementar soluções que façam sentido para o momento e identificar possíveis problemas, além de como o QA pode nos ajudar.

Analisando a API de entregas

Com a pasta aberta, dentro de src, ao abrir a API de entregas, encontramos um endpoint chamado Stats. Observamos que há uma query executada diretamente no endpoint. No controller, já temos uma execução de SQL sendo feita, e a query está escrita diretamente no código. Isso não é um padrão, como indicado nos comentários que mencionam que a query, em vez de utilizar o Sequelize, foi feita diretamente no arquivo do controller. Isso gera a desordem mencionada anteriormente. Precisamos corrigir isso, pois é um problema grave.

Para ilustrar, veja o código atual do endpoint Stats:

router.get('/stats', function(req, res) {
    // FIXME: Raw query em vez de Sequelize
    const query = `
        SELECT
            status,
            COUNT(*) as total,
            COALESCE(AVG(distancia_km), 0) as distancia_media,
            COALESCE(AVG(peso_kg), 0) as peso_medio
        FROM entregas.entregas
        GROUP BY status
    `;

    sequelize.query(query, { type: sequelize.QueryTypes.SELECT })
        .then(function(stats) {
            const totalEntregas = stats.reduce(function(acc, s) { return acc + s.total; }, 0);

            res.json({
                total: totalEntregas,
                por_status: stats,
                gerado_em: new Date().toISOString()
            });
        })
        .catch(function(error){
            console.error('Erro ao buscar estatísticas:', error.message);
            res.status(500).json({ error: 'Erro ao buscar estatísticas' });
        });
});

Esse código utiliza uma query SQL bruta, o que não é recomendado. Devemos refatorar para usar um ORM como o Sequelize para melhorar a manutenção e segurança do código.

Explorando a configuração de variáveis de ambiente

Além disso, ao analisar a estrutura do front-end da API de entregas, navegando entre as pastas como config, middleware, rotas, etc., percebemos que algumas constantes foram definidas no arquivo .env, enquanto outras não. Por exemplo, ao chamar a API de frotas, a configuração está no arquivo .env, mas isso não ocorre em todos os casos. O padrão é utilizar um arquivo .env, onde as variáveis são preenchidas conforme o ambiente, seja desenvolvimento, homologação, staging ou produção. Um padrão semelhante foi adotado, mas não em todos os arquivos.

Veja como a URL da API de frotas é configurada:

const API_FROTAS_URL = process.env.API_FROTAS_URL || 'http://localhost:8080/api';

E para a API de notificações:

const API_NOTIFICACOES_URL = process.env.API_NOTIFICACOES_URL || 'http://localhost:5000';

No serviço de notificações, ao chamar a API de notificações, a variável de ambiente está sendo utilizada. No serviço de frotas, a variável de ambiente também está sendo utilizada.

Identificando problemas de segurança

No arquivo auth.js, encontramos a chave secreta do JWT da autenticação inserida diretamente no código. Isso viola diversos padrões de segurança, pois essa informação pode ser facilmente acessada por pessoas desenvolvedoras ou mal-intencionadas, que poderiam utilizá-la para se autenticar no sistema. Normalmente, utilizamos outros meios para armazenar essa chave secreta, dependendo de como a aplicação está estruturada na cloud (nuvem), por exemplo. Neste caso, já identificamos um problema grave que precisa ser corrigido, relacionado à chave secreta no código.

const JWT_SECRET = process.env.JWT_SECRET || 'super-secret-key-that-should-not-be-hardcoded';

Além disso, o projeto apresenta várias correções necessárias para problemas não resolvidos anteriormente. Este é apenas o contexto da API de entregas, e já percebemos a complexidade de trabalhar com código legado, especialmente quando não foi bem construído.

Explorando a API de frotas em Java

Agora, vamos prosseguir. Vou fechar esses arquivos e seguir para a API de frotas, que é voltada para Java. Ao abrir as pastas "src/main" e "Java", observamos uma certa organização de pastas e pacotes, o que é positivo. No entanto, nem todas as classes estão bem organizadas. Por exemplo, a classe de veículos, Veiculos, é bastante extensa. No VS Code, o arquivo possui mais de 300 linhas, o que dificulta a compreensão. Existem vários to do's e fixes que complicam ainda mais o entendimento. Além disso, o uso de System.out.println para logging é inadequado em Java. Diversas partes precisam ser corrigidas, e a classe deve ser dividida em outras para reduzir a complexidade. Este é apenas um dos problemas que encontramos, e ao explorar outros arquivos, podemos identificar ainda mais questões.

Analisando a API de notificações em .NET

Por fim, analisamos a API do .NET, que é a API de notificações. Aqui também há uma certa organização de pastas. Dentro da pasta "Notificação", notamos que o arquivo é extenso e possui diversas responsabilidades diferentes. Ele envia SMS, e-mails e também lida com regras de negócio, como a criação de notificações que são salvas no banco de dados. Essas responsabilidades poderiam ser melhor divididas dentro do contexto de "Notificação". É exatamente isso que faremos nos próximos vídeos. Este é o contexto do back-end e, posteriormente, analisaremos o contexto do front-end. Vamos documentar todos esses débitos técnicos e solicitar a ajuda de uma IA para identificar os problemas no back-end e front-end do RotaLog. Nos encontramos no próximo vídeo. Até já!

Sobre o curso Engenharia de software na era da IA: trabalhando com legado, escala e múltiplos serviços

O curso Engenharia de software na era da IA: trabalhando com legado, escala e múltiplos serviços possui 316 minutos de vídeos, em um total de 55 atividades. Gostou? Conheça nossos outros cursos de IA para Programação em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Entendendo o projeto legado
• Navegando no workspace com a IA
• Diagnóstico assistido por IA
• Refatoração segura com IA
• Implementando feature cross-service
• Debug, observabilidade e método