Imersão - Integraçao entre sistemas. Plataforma em funcionamento

Introdução

Visão geral da seção: Nesta seção, Wesley dá as boas-vindas e apresenta o vídeo. Ele compartilha um vídeo com alguns profissionais de tecnologia e pede para que os espectadores identifiquem o que eles têm em comum.

• Wesley dá as boas-vindas aos espectadores.

• Ele compartilha um vídeo com alguns profissionais de tecnologia e pede para que os espectadores identifiquem o que eles têm em comum.

Desafios na carreira de TI

Visão geral da seção: Nesta seção, Wesley fala sobre seus desafios pessoais na carreira de TI e como ele superou esses obstáculos.

• Wesley compartilha sua experiência pessoal sobre a falta de evolução em sua carreira.

• Ele menciona como descobriu o curso Fusca Full Saiko e como isso ajudou a impulsionar sua carreira.

• Wesley destaca como o curso ajudou a melhorar seu desempenho no trabalho e aumentar sua moral com seu chefe.

• Ele enfatiza como o curso forneceu uma visão mais ampla do conhecimento necessário para resolver problemas técnicos em sua empresa.

Experiência pessoal no curso Fusca Full Saiko

Visão geral da seção: Nesta seção, Luciano compartilha sua experiência pessoal no curso Fusca Full Saiko e como isso o ajudou a conseguir um emprego na área de TI.

• Luciano fala sobre sua transição da área fiscal para a área de tecnologia.

• Ele menciona como desistiu de procurar emprego antes de receber uma ligação oferecendo uma vaga em Java.

• Luciano destaca como o curso Fusca Full Saiko o ajudou a melhorar suas habilidades técnicas e ser efetivado em seu trabalho atual.

A importância do conhecimento técnico

Visão geral da seção: Nesta seção, Wesley enfatiza a importância do conhecimento técnico para os profissionais de TI e como o curso Fusca Full Saiko pode ajudá-los a pensar além do óbvio.

• Wesley destaca que os profissionais de TI precisam pensar além do óbvio e ter clareza sobre as necessidades dos grandes sistemas.

• Ele apresenta Luiz Carlos, um dos tutores do curso, que irá ajudar os espectadores a entender melhor esses conceitos.

Introdução

Visão geral da seção: Nesta seção, o professor introduz a aula e apresenta o objetivo de integrar as tecnologias desenvolvidas durante a semana para criar um home broker.

• O professor apresenta o objetivo de integrar as tecnologias desenvolvidas durante a semana para criar um home broker.

• Ele mostra uma demonstração do home broker funcionando plenamente.

• O professor lista as tecnologias que serão utilizadas na aula, incluindo server e client components, eventos enviados pelo servidor e modo watch.

Desenvolvimento do Comando Simulator

Visão geral da seção: Nesta seção, o professor explica como desenvolver o comando Simulator.

• O professor mostra como rodar o Simulator e como ele cria ordens e faz transações.

• Ele explica que todas as transações são registradas no Kafka.

• O professor destaca que é possível inscrever-se nas collections usando poucas linhas de código para receber notificações em tempo real sobre atualizações nas coleções.

Eventos Enviados pelo Servidor

Visão geral da seção: Nesta seção, o professor explica como enviar eventos pelo servidor.

• O professor destaca que os eventos enviados pelo servidor permitem comunicação em tempo real entre front-end e back-end.

• Ele lista os tipos de eventos que serão criados: atualização do preço do ativo, nova ordem cadastrada, atualização de uma ordem existente e processamento de uma nova ordem.

• O professor explica como fazer a integração entre Next.js e Next.js para enviar esses eventos.

Conclusão

Visão geral da seção: Nesta seção, o professor conclui a aula e destaca os principais pontos abordados.

• O professor destaca que a integração entre as tecnologias desenvolvidas durante a semana permitiu criar um home broker plenamente funcional.

• Ele enfatiza que o uso de eventos enviados pelo servidor é essencial para permitir comunicação em tempo real entre front-end e back-end.

• O professor encerra a aula convidando os alunos para continuar aprendendo sobre desenvolvimento web.

Gerando as tipagens do Prisma

Visão geral da seção: Nesta seção, o palestrante fala sobre a necessidade de gerar as tipagens do Prisma e como fazer isso usando o comando "npx prisma generation".

Gerando as tipagens do Prisma

• Para gerar as tipagens do Prisma, é necessário usar o comando "npx prisma generation".

• As tipagens não estão incluídas na loja de módulos.

• É importante acompanhar o que está acontecendo no banco de dados usando o "npx prisma studio".

Iniciando a aplicação

Visão geral da seção: Nesta seção, o palestrante inicia a aplicação e verifica se ela está funcionando corretamente.

Verificando a aplicação

• Inicie a aplicação com "npm run dev".

• Acesse localhost:3001/wallet para verificar se a aplicação está funcionando corretamente.

• Verifique os logs de erros para identificar possíveis problemas.

Acessando dados no banco de dados

Visão geral da seção: Nesta seção, o palestrante acessa os dados no banco de dados e verifica sua integridade.

Acessando dados no banco de dados

• Use "npx prisma studio" para acessar os dados no banco de dados.

• Verifique se há registros no banco de dados.

• Faça uma limpeza dos registros desnecessários.

Integrando Next.js com Node.js

Visão geral da seção: Nesta seção, o palestrante integra Next.js com Node.js e verifica se a integração está funcionando corretamente.

Integrando Next.js com Node.js

• Use o endereço correto para acessar a aplicação.

• Verifique se há problemas de rota.

• Use o "extraHosts" do Next.js para fazer a integração.

• Faça as modificações necessárias no arquivo "etc/hosts".

Identificando problemas na aplicação

Visão geral da seção: Nesta seção, o palestrante identifica um problema na aplicação e busca uma solução.

Identificando problemas na aplicação

• Verifique os logs de erros para identificar possíveis problemas.

• Identifique a rota que está causando o problema.

• Verifique se há diferenças entre as rotas que estão funcionando e aquela que não está funcionando.

Usando o extraHosts do Next.js

Visão geral da seção: Nesta seção, o palestrante explica como usar o extraHosts do Next.js para fazer a integração com Node.js.

Usando o extraHosts do Next.js

• Use o endereço correto para acessar a aplicação.

• Use o "extraHosts" do Next.js para fazer a integração.

Configurando o Prisma

Visão geral da seção: Nesta seção, o instrutor configura o Prisma e exclui algumas transações para melhorar a performance.

Configurando o Prisma

• O instrutor configura o host do Docker interno.

• Ele adiciona a versão facultativa no Prisma.

• O instrutor volta para o Next.

Excluindo transações

• O instrutor exclui várias transações antigas.

• Ele exclui 96 transações restantes.

Ativando Corsa e atualizando componentes

Visão geral da seção: Nesta seção, o instrutor ativa Corsa e atualiza um componente de servidor para cliente.

Ativando Corsa

• O instrutor explica sobre a política de Corsa e como ativá-la.

Atualizando componentes

• O instrutor explica que um componente de servidor precisa ser atualizado para cliente.

• Ele menciona que usará "Hulk" e "use" passando funções cruas para pegar informações em um componente cliente.

Criando um arquivo de utilidade com SWR

Visão geral da seção: Nesta seção, o palestrante explica como usar o SWR para criar um arquivo de utilidade e obter ganhos de performance.

Usando o fator para capturar dados

• O fator é uma função que permite acessar os dados.

• O fator pode ser usado para fazer chamadas e retornar dados.

• Use a biblioteca SWR para capturar os dados do browser.

• O SWR retorna os dados consultados e um erro.

Desativando comportamentos indesejados

• Use um genérico para dar retorno ao componente.

• Adicione um fallback de dados enquanto a requisição ainda não terminou.

• Adicione uma interrogação para garantir que haja sempre um valor.

• Desative tanto a validação quanto o revalidação ou reconexão.

Usando o componente clight

• Use o componente clight para carregar resultados.

• Cuidado com renderizações excessivas.

Encerrando processo em caso de renderização excessiva

Visão geral da seção: Nesta seção, o palestrante explica como encerrar processos em caso de renderização excessiva.

Encerrando processo em caso de renderização excessiva

• Em caso de renderização excessiva, encerre o processo no gerenciador de tarefas do browser.

Criando uma API com Next.js

Visão geral da seção: Nesta seção, o palestrante demonstra como criar uma API usando Next.js e como implementar o cache interno para otimizar o carregamento.

Criação de uma API com Next.js

• É possível criar uma peia interna para utilizar o cache da mesma forma que a política do Cash é utilizada.

• O Wallet ID pode ser utilizado dentro da pasta criada.

• É possível criar um arquivo de rota para expor as funções com os verbos HTTP.

• Os mesmos arquivos podem ser usados para diferentes verbos HTTP.

• O processamento acontece no servidor e deve ser mantido interno.

• A lógica do Home Broker pode ser mantida e o resultado será os dados recebidos.

Envio de eventos

• O primeiro conceito de envio de eventos é apresentado: saber tudo que está acontecendo na carteira em tempo real.

• É possível enviar eventos dinamicamente em tempo real usando apenas o protocolo http, sem precisar criar um novo servidor ou usar websockets.

• Para enviar eventos, é necessário fazer uma chamada GET para a rota /eventos no servidor.

• O servidor abre a conexão e envia os eventos em tempo real.

Como trabalhar com eventos em Node.js

Visão geral da seção: Nesta seção, o palestrante explica como trabalhar com eventos em Node.js e como habilitar uma conexão ativa entre o servidor e o navegador.

Habilitando conexão ativa entre servidor e navegador

• Para manter a conexão ativa, informe isso para o browser. O browser não fechará a conexão e ela ficará aberta.

• Trabalhe mais com formatos de texto, como enviar um texto.

• HTTP por aba no domínio permite no máximo 6 conexões simultâneas. HTTP2 suporta até 16 conexões simultâneas por aba por domínio.

Habilitando eventos no Next.js

• Habilite um endereço no Next.js para enviar eventos.

• Crie respostas HTTP com headers específicos, como Keep-alive.

• É possível criar manualmente essa versão de eventos com qualquer linguagem de programação que suporte o protocolo HTTP.

Inscrevendo-se em uma coleção

• Use um método subscribe para se inscrever em uma coleção.

• O fluxo de eventos não será somente um método executando e devolvendo um resultado. Será necessário receber vários resultados ao longo do tempo.

• Use a Lib mongoose para fazer a inscrição na coleção.

Criando um modelo com Prisma e Mongoose

Visão geral da seção: Nesta seção, o palestrante demonstra como criar um modelo com Prisma e Mongoose.

Criando uma classe para o nosso Wallet

• Criação de uma classe para o Wallet.

• Uso do decorador @Collection para indicar que é uma coleção.

• Importação do tipo obsoleto documento.

• Descrição do objeto Wallet A7, que contém informações sobre a página e o esquema.

Registro do mongoose para conectar no banco de dados

• Chegada no módulo Raiz e registro do mongoose.

• Uso de mongos mod.fore Rute para conectar ao banco de dados.

• Instalação do módulo config para leitura automática das variáveis de ambiente.

• Adição da linha config em ódio para fazer a leitura dos arquivos .env.

• Chamar um gozo médio.

Utilizando o mongoose dentro do serviço

• Passagem de um objeto com nome da Collection que queremos manipular.

• Comunicação entre os serviços através da integração com o mongoose.

• Puxando o Wallet no topo usando a classe Model do mongoose passando a classezinha.

• Importação apenas dos esquemas que serão usados.

• Forçando um jet Model passando aqui o Wallet também que é o mesmo nome que foi registrado lá no módulo.

Trabalhando no nosso subscribe

• Trabalho no subscribe para manipulação da Collection.

Desculpe, mas não recebi nenhum arquivo de transcrição para trabalhar. Por favor, envie o arquivo de transcrição para que eu possa começar a criar as notas em markdown.

Descritivo do vídeo "MongoDB Change Streams com Node.js e Mongoose"

Introdução

• Visão geral da seção: Nesta seção, o palestrante apresenta a configuração do MongoDB Change Streams com Node.js e Mongoose.

Configurando o MongoDB Change Streams

• O servidor Express que está rodando precisa ser levantado novamente para fazer a conexão.

• Aguardar um pouco enquanto o servidor é recarregado.

• Os dados da coleção são exibidos no console. A coleção ao Wallet accett, ID do documento alterado e informações alteradas são mostrados.

• É explicado como filtrar eventos específicos usando watch. O evento de update é filtrado aqui.

• As opções de como lidar com os eventos são passadas em um segundo parâmetro. Aqui, full document update locap é usado para permitir que o documento inteiro seja recebido.

Usando Prisma Service

• O Prisma service é usado para chamar Alex e fazer uma consulta find unick. Isso permite que apenas uma luz seja usada para fazer a consulta.

Conclusão

• Visão geral da seção: Nesta seção, o palestrante concluiu a configuração do MongoDB Change Streams com Node.js e Mongoose usando Prisma Service para consultas mais eficientes.

O vídeo fornece uma visão geral sobre como configurar o MongoDB Change Streams com Node.js e Mongoose. Ele também explica como usar Prisma Service para consultas mais eficientes.

Passando dados para o servidor

Visão geral da seção: Nesta seção, o palestrante mostra como passar dados para o servidor e identificar eventos.

Criando um tipo de evento no Controller

• O palestrante explica que é possível criar um tipo de evento no Controller para identificar os dados que estão sendo transmitidos.

• Ele menciona que é comum utilizar o tipo do evento como "Messenger" para identificá-lo.

Identificando eventos na conexão do front-end

• O palestrante explica que é possível identificar eventos na conexão do front-end.

• Ele demonstra como a utilização de tipos de eventos pode tornar a captura dos dados mais fácil.

Conectando com o servidor usando SWR Subscription

Visão geral da seção: Nesta seção, o palestrante mostra como conectar com o servidor usando SWR Subscription.

Utilizando SWR Subscription

• O palestrante introduz a biblioteca SWR Subscription e explica sua utilidade em situações onde websockets ou Server-Sent Events são necessários.

• Ele demonstra como usar a função useSWRSubscription para se inscrever em uma URL específica.

• Ele menciona que é necessário converter os dados recebidos em texto para objeto antes de trabalhar com eles.

Atualizando elementos HTML com mil tente

• O palestrante introduz a função milTente, que permite forçar a renderização do componente ou fazer uma nova chamada HTTP.

• Ele demonstra como usar milTente para atualizar elementos HTML com a quantidade de ativos.

Atualizando a quantidade de um ativo

Visão geral da seção: Nesta seção, o palestrante discute como atualizar a quantidade de um ativo em uma carteira.

Atualização da quantidade do ativo

• Para encontrar o índice do ativo, é possível adicionar tipagem.

• Se o índice for igual a -1, significa que o ativo não foi encontrado.

• Se o ativo não for encontrado, pode-se propagar um erro ou simplesmente não fazer nada.

• Para atualizar a quantidade do ativo, é necessário passar o novo preço.

• Não é necessário passar A7 Price para atualizar a quantidade.

• É possível usar Chez para ver a quantidade desejada.

• É importante garantir que x seja possivelmente nulo e que Fine seja um número válido.

• Ao atualizar localmente no navegador sem forçar uma nova chamada, ganha-se performance.

Recebendo eventos com WebSocket

Visão geral da seção: Nesta seção, o palestrante discute como receber eventos usando WebSocket.

Recebendo eventos com WebSocket

• O subscription dá informações sobre os últimos eventos recebidos.

• É possível mostrar uma mensagem ao usuário quando seu ativo é atualizado.

• O código JavaScript puro faz a atualização do valor do ativo na carteira.

• É importante fechar as conexões abertas para evitar problemas no navegador.

Testando as funcionalidades

Visão geral da seção: Nesta seção, o palestrante testa as funcionalidades implementadas anteriormente.

Testando as funcionalidades

• É possível testar as funcionalidades abrindo o console do navegador.

• Ao atualizar a quantidade de um ativo, é necessário forçar uma atualização.

• É importante passar o look e o Next para forçar a atualização.

Atualização em tempo real com eventos

Visão geral da seção: Nesta seção, o palestrante fala sobre a atualização em tempo real com eventos e como isso pode ser aplicado ao serviço de ativos.

Padrão para trabalhar com atualizações em tempo real

• O palestrante menciona que já existe um padrão para trabalhar com atualizações em tempo real.

• Ele quer usar esse padrão para criar uma tela que liste todos os ativos ou pelo menos um grupo deles para seus clientes.

• Ele quer permitir que os clientes vejam os valores sendo atualizados em tempo real.

Criando o modelo do Acetil

• Para trabalhar com atualizações em tempo real, é necessário criar o esquema do Acetil.

• O palestrante mostra como criar o esquema do Acetil usando TypeScript e importando as bibliotecas necessárias.

Habilitando eventos no Controller

• No Controller, é necessário habilitar um evento declarando-o como SSE.

• É importante não esquecer de importar o Messenger.

Trabalhando com eventos

• O palestrante mostra como trabalhar com eventos usando a lógica de inscrição e subscription options.

• Ele demonstra como disparar um evento quando um ativo sofre uma atualização de preço.

• É possível ser mais específico e otimista na lógica dos eventos, mas isso seria apenas um refinamento.

Mudança no preço do ativo

• Para mudar o preço do ativo dentro da modelagem, é necessário puxar o valor do ativo na carteira.

• O palestrante mostra como mudar o valor do ativo e como lidar com possíveis erros.

Preço e Notificações

Visão geral da seção: Nesta seção, o palestrante discute a parte do preço e notificações. Ele mostra como trabalhar com a Horda e como se inscrever nos eventos da carteira.

Trabalhando com a Horda

• O palestrante cria um esquema para Horda integrado em seu módulo.

• Ele se inscreve nos eventos da carteira para ser notificado do que está acontecendo.

• Ele usa o operador ternário para passar dois eventos: update e order create.

Recebendo Notificações

• O palestrante consulta a ordem antes de receber as notificações.

• Ele usa o Postman para verificar se recebeu os eventos de criação de ordem.

• Ele verifica se recebeu o evento de atualização após mudar o valor da ordem no Prisma Estúdio.

Trabalhando com Componentes Server e Client

• O palestrante explica que é necessário criar um novo componente com lógica para ter eventsourcing no browser.

• Ele exporta esse novo componente, chamado "Cinto", que será um easy client recebendo os mesmos parâmetros que Maior dos recebe.

Criando notificações em tempo real com React e Server-Sent Events

Resumo da Seção: Nesta seção, o instrutor demonstra como criar notificações em tempo real usando React e Server-Sent Events.

Configurando a página de pedidos

• Para habilitar as notificações, é necessário configurar a página de pedidos.

• É preciso passar um ponto para as notificações.

• A página deve ser posicionada corretamente.

Lógica do servidor

• O componente Orders recebe um parâmetro envolvendo o nosso componente.

• A lógica do servidor é usada para fazer a chamada à API no servidor.

• O SWR Subscription importa uma função nova no React chamada start transition que pode chamar uma server Action dentro dela.

Alternativas para trabalhar com atualizações

• É possível usar a server Action como alternativa para trabalhar com atualizações no navegador.

• Quando uma nova ordem é cadastrada, é possível propagar uma revalidação que fará aquele componente recarregar.

• A ideia da imersão é dar duas possibilidades: trabalhar mais cliente ou mais servidor.

Atualizando os pedidos

• Ao atualizar um pedido, pode-se mudar qualquer coisa.

• Existe uma função nova no React chamada start transition que pode chamar uma server Action dentro dela.

• É preciso criar uma pasta de Actions e começar a colocar as ações.

• A ação é bem simples: exporta uma função revalidate passando o URL que é string.

• O arquivo deve ser colocado em uso server no topo dele.

Testando as atualizações

• As atualizações podem ser testadas no Prisma Studio.

• Ao mudar o status do pedido, ele deve ser atualizado na página.

Atualização de Pedidos

Visão Geral da Seção: Nesta seção, o palestrante discute a atualização de pedidos e como isso pode ser feito no passado. Ele também menciona a importância do reuso de componentes.

Mudança para o Passado

• O palestrante menciona que os eventos devem estar no passado e não no presente.

• Ele mostra como mudar o tempo dos eventos para o passado.

Reuso de Componentes

• O palestrante destaca a vantagem do reuso de componentes e como isso pode ser útil em diferentes partes da aplicação.

• Ele compara duas alternativas para atualizar um componente e destaca as vantagens de cada uma delas.

Gráficos em React

Visão Geral da Seção: Nesta seção, o palestrante fala sobre boas práticas na montagem de gráficos em React e como criar um componente cliente para receber atualizações dos ativos.

Boas Práticas na Montagem de Gráficos em React

• O palestrante destaca a importância do reuso de componentes ao montar gráficos em React.

• Ele explica que é importante ter um componente mais abstrato que permita especialização nos lugares, mas permita o reuso.

Criação do Componente Cliente

• O palestrante mostra como criar um componente cliente para receber atualizações dos ativos.

• Ele mostra o resultado final do componente e como ele pode ser usado na página.

Consulta de Ativos Específicos

• O palestrante fala sobre a importância de habilitar uma rota para consultar um ativo específico e mostrar suas informações no gráfico.

Trabalhando com gráficos e histórico de ativos

Visão geral da seção: Nesta seção, o palestrante discute como trabalhar com gráficos e históricos de ativos.

Chamada para API do Next.js

• Para trabalhar com cache, é possível usar a API do Next.js.

• É importante minimizar o acesso à aplicação ao fazer chamadas após as 18 horas.

• O Fatcher é usado para fazer chamadas enquanto não há resposta.

Modelagem de dados para histórico de ativos

• É possível salvar modificações no valor dos ativos ao longo do tempo em uma coleção separada.

• Isso permite que os usuários vejam a movimentação dos preços desde o início da bolsa.

• Será usada uma nova modelagem de dados para isso, incluindo dois novos modelos: A7 History e A7 Daily.

Implementando relacionamentos no esquema

• Os relacionamentos entre os modelos precisam ser adicionados ao esquema para que o gráfico possa ser gerado corretamente.

Atualizando ordens concluídas

• Após uma ordem ser concluída, várias informações são atualizadas automaticamente, incluindo o preço do ativo na data da transação específica.

Consultando todo o histórico de um ativo

• É possível consultar todo o histórico de um determinado ativo passando seu símbolo como parâmetro.

Eventos

Visão geral da seção: Nesta seção, o palestrante fala sobre eventos e como eles são usados em um projeto. Ele também mostra como pegar os eventos e mostrá-los em um gráfico.

Pegando eventos para mostrar no gráfico

• O palestrante mostra como pegar os eventos para mostrar no gráfico.

• Ele remove a tipagem desnecessária do código.

• O evento é iniciado com um console.log.

• O modelo de dados é mostrado, incluindo o ID do evento, a data e o preço.

Atualizando o gráfico com a referência do componente

• É mencionado que há uma referência para atualizar o gráfico.

• A referência expõe um método chamado "update".

• Um tipo chamado "chartRef" é criado para capturar a referência do componente.

• A variável "chartRef" é passada para o método "update".

Utilizando Next Commander para criar comandos interativos

• O palestrante menciona que será difícil testar manualmente e sugere usar uma biblioteca chamada Next Commander.

• Ele cria um arquivo na raiz chamado command.ts que contém um comando interativo chamado Simulator.

• É explicado que esse comando acessa todos os serviços da aplicação.

• O comando Simulator é mostrado e explicado.

• O método "Simulator Price" é mencionado, que limpa o banco de dados e cria ativos e carteiras.

Criação de Ativos e Obras

Visão Geral da Seção: Nesta seção, o palestrante fala sobre a criação de ativos e obras usando o Nitronzaction.

Criação de Ativos

• O palestrante tem 10 mil em um ativo e 20 mil em outro.

• A criação de ativos é feita com o Nitronzaction.

Criação de Obras

• É explicado como criar obras usando o Java Script.

• As transações são geradas para que uma carteira não venda um ativo enquanto outra está querendo comprá-lo.

Renderização do Gráfico

Visão Geral da Seção: Nesta seção, o palestrante fala sobre a renderização do gráfico e a importância do tempo entre as renderizações.

Tempo Entre Renderizações

• É explicado que é necessário ter um tempo entre as renderizações para evitar problemas no navegador.

• Um sleep de dois segundos é adicionado após cada execução para evitar que o gráfico seja renderizado muitas vezes seguidas.

Comando Para Iniciar a Aplicação Web

• É mostrado como iniciar a aplicação web com um comando específico.

• O duplo Dash é usado para passar opções para o comando.

Uso do Kafka e Golem

Visão Geral da Seção: Nesta seção, o palestrante fala sobre o uso do Kafka e Golem.

Uso do Kafka

• O Kafka é usado para enviar mensagens entre os serviços.

Uso do Golem

• O Golem é usado para testar serviços em memória.

Exportação de Dados

Visão Geral da Seção: Nesta seção, o palestrante fala sobre a exportação de dados.

Exportação de Dados

• É explicado como exportar dados para que possam ser usados em outros módulos.

Rodando Prisma Studio

Visão Geral da Seção: Nesta seção, o palestrante fala sobre como rodar o Prisma Studio.

Atualização do Esquema

• É necessário atualizar o esquema antes de rodar o Prisma Studio novamente.

Comando Para Rodar o Prisma Studio

• É mostrado como rodar o Prisma Studio com um comando específico.

• O nome correto do comando é verificado.

Problemas com atualização de dados

Visão geral da seção: Nesta seção, o palestrante discute problemas que encontrou ao tentar atualizar os dados e como resolveu esses problemas.

Registro do controle necessário

• O registro do controle é necessário para atualizar os dados.

• O serviço precisa ser registrado.

Atualização não possível

• A atualização dos dados não foi possível devido a um erro.

• Não adianta atualizar agora que o Kafka foi ativado. É preciso esperar.

Atualizando impostos e resolvendo erros

Visão geral da seção: Nesta seção, o palestrante fala sobre a necessidade de atualizar impostos e como ele resolveu um erro no aplicativo mod.

Atualizando impostos

• Os impostos precisam ser atualizados.

Resolvendo erros no aplicativo mod

• Houve um problema com o nome do arquivo no aplicativo mod.

• A mensagem "started" deve ser registrada na log.

Execução de comando e gráfico escalonável

Visão geral da seção: Nesta seção, o palestrante demonstra a execução de um comando e como criar um gráfico escalonável.

Execução de comando

• É possível executar comandos sem problemas.

Gráfico escalonável

• O gráfico pode ser escalonado.

• O gráfico é atualizado à medida que os dados são atualizados.

• As ordens estão sendo exibidas no gráfico.

• É possível fazer ajustes de CSS para o gráfico ficar melhor.

Conclusão

Visão geral da seção: Nesta seção, o palestrante conclui a imersão e agradece aos participantes.

Agradecimentos

• O palestrante agradece aos participantes pela presença na imersão.

• Aplausos dos participantes.