Transcrições
1. Apresentação do curso: Olá, bem-vindo à introdução ao curso de nuvem do console. Meu nome é Shannon, e estou
ansioso pelo nosso tempo
juntos neste curso. Durante a duração deste curso, você estará focado
no seguinte. Primeiro, vamos
ensiná-lo em eventos de demanda, habilidades de
streaming em confluentes por meio de exercícios práticos de laboratório. Também ensinaremos o uso do ambiente
de
nuvem do console, que é extremamente fácil de
usar e muito funcional. Os principais conceitos neste
curso são explicados com visuais
apropriados para que o cimento seja fácil e que você os
entenda rapidamente. Também teremos um projeto capstone
no final do curso. Você encontrará
testes regulares durante a duração
deste curso para testar seu conhecimento sobre o que
aprendeu, bem
como cimentar alguns
fundamentos à medida que avançamos. Conheça nossa equipe de
instrutores que
criaram e projetaram
este curso. Juntos, temos pouco mais de
dez anos de experiência em implementações
práticas
de tecnologia no ensino de cursos técnicos
em nível universitário. Os membros da nossa equipe têm
especializações
nas áreas de tecnologia da
informação, engenharia de
software e ciência e design de
dados. Roteiro de aprendizado que
seguiremos para este curso. Vamos começar com o
Apache Kafka e ensinaremos
tudo o que você precisa saber sobre isso para trabalhar
com contornos. O próximo passo é realmente
mostrar confluente e mostrar o que se
trata e configurá-lo para você. Depois disso, vamos dar
uma olhada no caso igual db, como usamos isso e quais são
seus aplicativos. Seguindo em frente,
vamos explorar fluxos, o que eles são, as
bibliotecas envolvidas e como você pode trabalhar com eles. Por fim, vamos olhar para a conexão
católica
sobre como podemos trabalhar com isso e como podemos vincular
nossos projetos externamente. Depois de terminarmos
todos esses conceitos, vamos seguir em frente
e criar dois projetos. Kafka é um
serviço de streaming de dados que permite ao produtor
escrever mensagens para um tópico que foi
consumido com o consumidor. Embora esse conceito seja
extremamente simples na prática, as coisas podem ficar um pouco confusas
e perdidas ao longo do caminho. É por isso que tentamos explicar
os conceitos neste fim de semana. Com explicações visuais Entre confluentes há um serviço de streaming de
eventos baseado em nuvem. Ele fornece o ambiente
na forma de clusters
para evitar streaming e fornece uma visualização
muito boa
das operações. Dito isso, você
vai ver muito
essa tela
durante o curso. Além da teoria e explicação, três partes
deste curso para casa. Da mesma forma que estamos trabalhando
muito em biópsia, veremos
como podemos executar em nossa nuvem de console e
Kafka usando a CLI. E vamos
criar um projeto no qual vamos fazer
algo incrível e ver como ela produz
todas essas informações em nosso streaming de eventos
é uma frase de grande objetivo. E as empresas da Fortune 500 hoje, essas são apenas algumas
das empresas que precisam de especialistas em streaming de
eventos para preencher suas
operações diárias e necessidades críticas de desenvolvimento de
software. Estamos ansiosos para que
você participe do nosso curso. E prometemos que este
curso ajudará você a construir sua base de
streaming de eventos e console
de conhecimento. Isso ajudará você a destacar
seu currículo e exigir um
salário competitivo no mercado.
2. O que é Streaming Analytics: Olá, e seja bem-vindo a este
curso, onde vou ensiná-lo
a usar aplicativos de
streaming de eventos confluentes e seus eventos. Nesta primeira seção,
discutiremos Apache Kafka e
tudo o que você precisa saber sobre isso para
entender e usar o confluent como um serviço. Primeiro, precisamos entender
o que a
análise de streaming de buzzword significa mesmo e por que
ela é tão popular nos dias de hoje. O que é análise de streaming? Em termos leigos? É o
processamento constante de dados à medida que são gerados e
recebidos em tempo real. Esses dados são encontrados
na maioria dos lugares. Por exemplo, a forma
mais comum de dados que é usada para ser analisada na análise de streaming são as informações de mídia social. No momento em que você executa
algo nas mídias sociais, esse evento é transmitido em tempo real para ser processado, a fim de mostrar
conteúdo
mais relevante para
seus gostos
em vez de coisas que você não faria gosto de ver. No passado. E,
na verdade, em muitos lugares ainda hoje, os dados eram enviados em lotes e
não como um fluxo
contínuo. Os dados foram coletados
até um intervalo de tempo. E quando o
ponto médio interno chegou, os dados eram enviados como um pedaço
grande para ser processado. Embora esse processo seja muito mais barato do que o streaming de
dados em tempo real. Ele não fornece insights
em tempo real e não pode ser usado para ações
instantâneas e geração de gráficos
em tempo real. análise de streaming
foi criada para resolver esse problema
no processamento em lote, que
decisões em tempo real poderiam ser tomadas e ações poderiam ser tomadas. Agora vamos ver como a análise de
streaming funciona. A primeira parte do
streaming de eventos é
o evento produzido. Este evento pode ser produzido
por algum dispositivo ou aplicativo ou qualquer outro
produtor, é essencialmente apenas uma mensagem. Essa mensagem é enviada para um hub. Esse Q é a mensagem
por trás de outras mensagens e torna ingerível dentro do serviço de análise de streaming. Na fase de
análise de streaming, é decidido o que
fazer com essa mensagem. Seja para apresentá-lo em um
gráfico em algum painel ou para enviar um comando para executar uma determinada ação
ou evento
apenas para armazenar essa mensagem. Tudo isso é decidido
na parte de análise de fluxo. Por fim, a mensagem
é enviada a partir
do serviço Stream Analytics para ser consumida pelo consumidor final. Esses processos podem
parecer um pouco técnicos. E você pode estar se perguntando, neste
momento, por que passar por esse processo
em primeiro lugar. Há uma boa
quantidade de vantagens usar
a análise de streaming. Usando a visualização de dados. Mesmo alguém que não consegue
ler os números corretamente, pode entender como
as coisas estão progredindo. Além disso, ele oferece uma vantagem
competitiva à medida que você obtém insights
em tempo real
e pode fazer movimentos mais rápidos do que sua concorrência
pode até perceber. Ele também oferece uma visão muito
mais profunda e clara operações, pois você sabe quais operações estão sendo
executadas em tempo real. A capacidade de obter informações assim que são
produzidas pode criar, bem como identificar oportunidades
perdidas no mundo dos
negócios e muito mais. Por fim, identificar tendências com análise de
streaming
pode ajudar a mitigar as perdas alertando a empresa as coisas certas
no momento certo. Muitas empresas no mercado hoje empregam o
uso de
análises de streaming com
ainda mais adotá-lo todos
os dias. A maioria das organizações está
descobrindo sua necessidade dados contínuos
em tempo real e quanto eles servem
para ganhar com eles. Pode não ser aparente
na superfície,
mas em muitos setores são candidatos
naturais
para streaming de dados. Por exemplo, considere as
seguintes indústrias. Finanças, é
fundamental saber se uma fraude está sendo
cometida em tempo real. Caso contrário, isso poderia levar a uma
enorme perda para a empresa. Além disso, a análise de
mercado em tempo real é um elemento fundamental nas
decisões de negócios no comércio eletrônico. Vejamos o pai de
todo o comércio eletrônico diz Amazon. A Amazon lida com uma quantidade absolutamente
enorme de dados. E ele usa esses dados para ajustar
continuamente os negócios e os valores de seus produtos
para otimizar suas células. Além disso, ajuda nas recomendações de
produtos para os clientes, além de otimizar a logística de
toda a operação. Amazon realmente tem seu
próprio produto para
isso, é chamado Amazon Kinesis. Nos esportes. Vamos dar uma
olhada na Fórmula 1. Cada carro de Fórmula 1
produz gigabytes de dados através do grande número de instrumentos
instalados. Só durante a corrida, as equipes coletam uma
enorme quantidade de dados de que precisam
para tomar decisões em tempo real que podem tomar ou quebrar
a corrida por elas. A mesma lógica também
se aplica aos jogos online, onde detalhes técnicos e dados
do jogador são usados para otimizar o desempenho do jogo e ajustar a experiência
geral.
3. O que é Apache Kafka: Quando você diz o termo análise de
streaming, você descobrirá que ele está
associado principalmente ao Apache Kafka. Isso porque o apache Kafka
é o serviço de
streaming de dados mais comum que a maioria das empresas usa para seus requisitos de
streaming de dados. Vamos explorar o que é
Apache Kafka. Em um livro didático. O Apache Kafka é um serviço de
streaming de dados. Ele é de código aberto e usado por milhares de empresas
para análise de streaming. Em uma definição mais simples, ele fornece o serviço discutimos quando analisamos esse diagrama de fluxo de como a análise de
streaming funciona. O que o Apache Kafka
faz é pegar eventos ou mensagens
de um produtor. Agora esse produtor pode ser um dispositivo
IoT ou um smartphone, e ele o envia
para o Apache Kafka. Apache Kafka então o
gerencia de tal forma que
possa ser dado
a muitos consumidores, elimina a necessidade de ter fluxos de dados
individuais de
cada produtor para um consumidor. E, essencialmente, faz com
que cada produtor e consumidor tenha
apenas um único fluxo de dados que não é afetado
por fatores externos. Vejamos um exemplo
para uma melhor compreensão. Agora, dizendo que você
tem para produtores e três consumidores
sem Apache Kafka, cada produtor precisa de um fluxo para um consumidor com dois produtores
e três consumidores. Isso nos dá um total de
seis fluxos para gerenciar. Esses fluxos são acoplados, o que quer dizer que eles podem sufocar devido a fatores externos. consumidor lento pode
afetar o produtor. adição de consumidores
afetaria os produtores. A falha de um consumidor
bloquearia um fluxo inteiro. Há muitas fraquezas
em um sistema como esse. Vamos pegar o sistema
de antes e adicionar mais três produtores
e mais consumidores. Sem o Apache Kafka,
precisaríamos
manter e gerenciar 25 fluxos. Agora são muitos fluxos
e muita manutenção, que também significa altos custos, bem
como riscos adicionais. Com o Apache Kafka,
precisaríamos apenas de dez fluxos
e temos
a certeza de que esses fluxos
são dissociados e não serão afetados por uma capacidade de produtores ou consumidores de
executar suas tarefas. A partir do exemplo, agora você deve ser capaz de dizer o quão vantajoso Apache Kafka é e quão
importante o serviço oferece os benefícios do Kafka
ou que é muito rápido, facilmente escalável,
infinitamente confiável, extremamente durável e, o melhor
de tudo, é de código aberto. No entanto, você também pode
encontrá-lo como um serviço gerenciado, como veremos
mais tarde durante este curso.
4. Arquitetura do Kafka: Agora que sabemos
o que
é Apache Kafka e para que serve. Vamos ver como ele
funciona por dentro. Dentro do Apache Kafka, você encontrará a
seguinte competência. Produtores, consumidores,
corretores, tópicos, partições, clusters
e o zookeeper. Vamos analisar
cada confiança separadamente e
ver o que elas fazem. Produtores. Esses são os elementos que
produzem os eventos são mensagens
enviadas para o Apache Kafka. Como discutimos anteriormente, estes podem ser um dispositivo
ou um aplicativo. As mensagens que
os produtores enviam são escritas em um tópico com mensagens
semelhantes dentro. É importante
entender que vários produtores podem existir
dentro do mesmo aplicativo. Todas as mensagens
que são produtoras produzem sentido direto
para o cluster Kafka. Consumidores. Estes são os caras no extremo oposto
do produtor. Eles estão lá para pegar
as mensagens
do produtor e ler, ou em um
sentido mais técnico, consumi-las. Os consumidores se inscrevem em tópicos. E quando as mensagens são
enviadas para esses tópicos, o consumidor consome essas
mensagens à medida que elas vêm. Ao trabalhar com o Apache Kafka, vários consumidores podem consumir a mesma mensagem
do mesmo tópico. Embora as mensagens sejam consumidas, elas não são destruídas
após o processo. Essa é uma das
belezas do Apache Kafka. Os consumidores também podem consumir
diferentes tipos de mensagens dos
clusters. Além disso, os consumidores sabem
exatamente onde os dados que precisam consumir estão localizados
dentro do cluster Kafka. Corretores. Quando discutimos como os produtores enviam mensagens para o Apache Kafka, onde eles realmente
enviam essas mensagens são os corretores dentro
do cluster Kafka. Os corretores são os servidores Kafka
que recebem e armazenam essas mensagens para os consumidores as levem
e consumam. Um cluster Kafka pode
ter vários corretores e cada corretor gerencia
várias partições. Como veremos em breve. Tópicos. Esses são simplesmente os canais
definidos através dos quais os
dados são transmitidos. Os produtores produzem suas
mensagens para tópicos. Os consumidores se inscrevem em tópicos para consumir as
mensagens dentro deles. É basicamente apenas um meio
de compartimentalizar e organizar mensagens e
ordená-las por suas características particulares. Tópicos de nomes de
identificação exclusivos dentro do cluster Kafka. E eles serão
vários tópicos. Não há limite definido. Partições. Os tópicos são divididos nessas partições e são
replicados para outros corretores. Vários consumidores podem ler um tópico em paralelo
com a ajuda disso, com partições,
os produtores podem adicionar chaves aos seus mestres para controlar qual partição a mensagem vai. Caso contrário, ele só vai ao redor
e ao redor do padrão Robin, onde
uma partição recebe uma mensagem e a outra
partição recebe a próxima, e assim por diante e assim por diante. As chaves permitem que o produtor
controle a ordem do processamento de
mensagens, o que pode ser útil
se o aplicativo exigir esse controle
sobre os registros. Assim como os tópicos, não há limite
definido para partições. Dado que o cluster
é a capacidade de processamento pode lidar e gerenciar a TI. Clusters. Esses são os sistemas
que gerenciam os corretores. É essencialmente
toda a arquitetura de corretores que
chamamos de cluster. As mensagens são gravadas em tópicos
que estão dentro de corretores, que estão dentro de clusters. Essas mensagens são então lidas por consumidores seguindo
a mesma hierarquia. O Zookeeper, esse elemento é responsável por gerenciar e coordenar o cluster Kafka, como um maestro
de uma orquestra. Ele notifica todos os nós do sistema quando ocorre uma alteração de
topologia. Isso pode ser a união de um novo corretor ou até mesmo
a falha de um. O Zookeeper também permite eleições de
liderança
entre corretores e pares de partições de tópicos para determinar qual corretor
deve ser o líder uma determinada partição e quais possuem
réplicas desses dados. Em termos leigos, o Zookeeper gerencia e
coordena tudo o
que o cluster Kafka faz e fornece proteção contra falhas
para um dia chuvoso.
5. Kafka de solução gerenciada: Vejamos as soluções
gerenciadas disponíveis no mercado
para o Apache Kafka. Neste momento, em 2021, existem vários provedores de soluções
gerenciadas
para o Apache Kafka. Um deles sendo confluente. Além disso,
também temos Azure, HDInsight, AWS, Kinesis,
em vez disso cluster. E até há muitas
vantagens em pagar um provedor de serviços gerenciados pelo Apache Kafka em vez usar o sabor de
código aberto dele. Há muitos problemas
associados ao kafka de código aberto e muita gestão e manutenção
precisam ser feitas regularmente. Há tantas operações
que precisam ser
executadas apenas para
fazer as coisas funcionarem. Com um serviço gerenciado. Você não precisa se preocupar em
executar nenhuma operação,
daí o termo sem operações . Além disso, você não
precisa baixar nenhum arquivo ou gerenciar
nenhum arquivo localmente. Tudo é feito na nuvem. Por fim, você pode
ter certeza de que você estará executando Kafka
sem problemas sem problemas. Pense em usar o código aberto
como um motor de carro gratuito. É poderoso e pode
gerar muito torque,
mas, por si só, não pode fazer
nada. Não até que você
construa o resto das peças necessárias para tornar
o motor útil. As soluções gerenciadas por comparação são como
carros de pleno direito prontos para dirigir. Não há problemas de configurar
muito nada, basta virar uma chave e começar. É essa conveniência
que muitas empresas olham ao considerar soluções
gerenciadas.
6. A nuvem Confluente: Iniciando a nuvem
confluente. Vamos
começar as coisas
fazendo algumas
tarefas básicas dentro de conflitos. Vamos configurar um
cluster do que um tópico. E, em seguida,
veremos como podemos criar produtores e
consumidores que
enviarão mensagens de e para esse tópico usando o
Console e a Cloud CLI. Para começar
com o confluent, a primeira coisa que
teremos que fazer é ir ao site do console, que é apenas confluent.io. Uma vez lá, você pode ver a opção de
começar gratuitamente. Quando você clica nele, você receberá
suas
opções de implantação e você pode simplesmente escolher a
opção de implantação e totalmente gratuita. Aqui você pode preencher seu nome
completo, sua empresa, país de
e-mail e escolher uma senha e
clicar neste botão. Quando você fizer isso,
como diz aqui, você receberá
US$400 para gastar no Console e na Nuvem durante
seus primeiros 60 dias. Quando você preencher este formulário
e clicar em Iniciar gratuitamente, ele enviará um link para
o seu e-mail, onde você
terá que confirmar a propriedade
e o acesso a esse e-mail, a partir do qual você
pode entrar em conflito. Como já temos uma
conta com confluente, não
faremos isso,
em vez disso, entraremos no confluente. Para fazer isso, o que vamos ter que fazer é voltar para a página
Começar. E só diz
na parte inferior aqui, eu tenho um login na conta. Lá vamos nós. Abra isso em uma nova guia onde podemos fazer login. Lá vamos nós. Esse é meu e-mail. Eu clico em Avançar,
essa é minha senha. Eu clico em Avançar. Agora, este é o
ponto em que o conflito começará a
fornecer um tutorial sobre como você
deve configurar seus clusters no
Console e no Cloud. Este é um excelente tutorial se você quiser aproveitar o tempo, eu recomendo que você
passe por ele e leia sobre ele. No entanto, para nossos projetos, estaremos fornecendo
todos os materiais que você precisará
para criá-los. Há esse botão aqui
que diz Criar cluster. Vá em frente e clique nele. E agora você receberá três opções diferentes
para criar um cluster. Você tem seu cluster básico, seu cluster padrão
e seu dedicado. Agora, o básico é
aquele que usaremos
porque, como você pode ver, ele não tem custo baseado
associado a ele. E tem muitos limites
de uso. Você tem uma entrada
de 100 mgs, saída de 100 MBAs e armazenamento de
até 5 mil GBs. Ele pode suportar alto fluxo de dados. Não estaríamos chegando
perto desses números, não em nossos projetos. Podemos apenas selecionar
o tipo básico por uma questão de conhecimento, é bom saber que, se você optou pela opção
padrão, custará US$1,50 por hora. E ele pode suportar mais armazenamento. Na verdade, você pode
levá-lo para armazenamento ilimitado. Esse é
apenas o único benefício que você vai conseguir de
tomar o padrão sobre o básico. Quando você passa para dedicá-lo,
você pode ver que, à medida
que avança nesta barra, você obtém cada vez mais benefícios. Então você chega a um ponto em
que eles dizem que entrou em contato para que possamos gerenciar algo para clusters
dedicados. Mas como não estamos indo
para nenhuma dessas opções, vamos começar um cluster
básico em andamento. Quando você chega a esta região, área onde eles perguntam qual
região você deseja selecionar. Aqui você pode ver como o
confluent
é realmente associado à AWS,
gcp e Azure. E você pode ver que você tem eleições
de
serviço de todas elas, você pode escolher
um servidor da AWS ,
um servidor GCP ou um servidor do Azure, que quiser, ou qualquer serviço
que você esteja já está usando. É ideal normalmente que,
se você quiser conectar kafka a um serviço que
já tenha em execução, crie o cluster em uma região usando um serviço que você já
tem feito antes. Por exemplo, digamos que você
tenha um Hub IoT do Azure. Você deseja usar o confluent
para o streaming de eventos, então provavelmente deve
usar o Microsoft Azure para hospedar seu cluster
confluente. Geralmente, torna as coisas mais
suaves e
facilita as coisas e há menos aborrecimentos
e o processo Connect, mas mais do que
isso, é fácil de
gerenciar e reduz a latência de nossos projetos uma vez que não
temos nada mais acontecendo, podemos ir direto
para lá vamos. Podemos simplesmente escolher. Não é nenhuma Ásia,
Cingapura, lá vamos nós. Não precisamos de uma disponibilidade de
várias zonas. zona única funciona
perfeitamente bem para nós. Então esse é exatamente o que
vamos buscar. Agora, quando você chegar a esta
terceira página,
ela solicitará um cartão de crédito. E ele cobrará esse cartão de
crédito inicialmente, mas você será
reembolsado seu valor, e ele precisa de um
cartão de crédito para verificar. Então, no caso de você ultrapassar seu limite ou
ultrapassar os 60 dias, ele lhe envia uma notificação
para que você saiba, hey, se você quiser continuar
usando confluente, avise-nos cobraremos no
cartão e nós só manterá todos os clusters que você tem
nos projetos que você tem. Portanto, esse cluster está
perfeitamente bom. Podemos chamar esse
cluster de sublinhado 0, que funciona para nós. E podemos simplesmente
iniciar esse cluster. Lá vamos nós. Com isso. Configuramos
nosso cluster de console. Agora vamos prosseguir com a criação de
um tópico em nosso cluster catódico, bem
como fazer login em nossa nuvem confluente
por meio de nossa CLI. Para isso, vamos
para confluente agora. A partir daqui, podemos
voltar ao link Conceitos
básicos e apenas fazer login. Lá vamos nós. Esse é o meu e-mail,
então vou clicar em Avançar, essa é minha senha. Vou fazer login. Lá vamos nós. Depois de ter uma configuração de cluster, isso é o que
você verá dentro do confluent. Isso mostrará que
você tem uma configuração de cluster. É ao vivo, está funcionando. Então, vá
em frente e clique neste cluster
que você criou. Quando você estiver dentro, você
verá o painel. Você verá que ele
oferece várias
opções nas quais você
pode canalizar dados, configurar um cliente se você
quiser configurar a CLI. Vamos
configurar a CLI em breve, mas antes disso
vamos configurar um tópico. Vamos falar sobre o tópico
aqui e criar um tópico. Podemos dar a este tópico qualquer nome. Podemos dizer que ele tem assuntos. Por que não? Podemos fazer esses cursos escolares, e podemos simplesmente deixar
isso por
padrão, enquanto você seis, não mudará
muito de nada, então podemos simplesmente
criá-lo com seus padrões. Tivemos mais de duas mensagens. Assim, podemos produzir nova
mensagem para este tópico. Podemos dizer que lá temos uma
vista para a montanha CA, todo o resto. Ok, então, como
não queremos enviar nenhuma mensagem técnica por enquanto neste
momento, estamos apenas tentando
entender quais tópicos são, o
que eles fazem e como mensagens seriam enviadas de volta e em diante e como os veríamos. Vamos esquecer todos esses bits técnicos
de código que estão
na seção de valor e podemos apenas
dar qualquer valor, digamos que lhe damos o
assunto do inglês. Isso é sempre um assunto divertido. E podemos transformar
esse volume para um. Você pode produzir
isso. Lá vamos nós. Árvore de partição inglesa, incrível. Então podemos dizer que
queremos produzir não. Você pode dizer que queremos
outro assunto, matemática. E acho que o
último seria ciência. Dizemos que queremos que nossa mensagem
final seja ciência. Lá vamos nós. Agora temos três mensagens
que configuramos. Estes são apenas três assuntos
que dissemos que, ok, são três mensagens sob o tópico de assunto
ou assuntos. No nosso caso, como podemos
ver aqui, assuntos. E só queremos passar essas três mensagens
que temos ciência, matemática e inglês
como assunto. Agora que
configuramos nosso tópico e
temos algumas mensagens
dentro do nosso tópico agora, provavelmente
devemos seguir em
frente e tentar configurar nossa CLI para que
possamos realmente configurar um consumidor. As construções
são muito simples. Se você passar aqui para
a página da CLI de configuração, todas as instruções estarão
bem ali à sua frente
e você pode simplesmente copiar
esses comandos. Se você estiver trabalhando em um Mac, isso deve ser bastante simples pois
esse comando
funcionará imediatamente. Não haverá nenhum problema. No entanto, se você é como
eu e estiver usando, está tentando
configurar nuvem
ou CLI confluente em uma máquina Windows, você precisa de um terminal
Linux para fazer isso. Se você estiver no Windows 11, para obter uma janela, o
terminal Ubuntu é muito fácil. Tudo o que você precisa fazer é ir
para a Windows Store. A partir daqui, você pode
procurar pelo Ubuntu. Ubuntu, você receberá
este aplicativo Ubuntu, bem
como Ubuntu 12.04
LTS e 18.04 LTS. Como já tenho
isso instalado, só
tenho que ir
em frente e abri-lo. Eu tenho que aconselhar
vocês, porém,
que, se você for
configurar uma benção para gostar disso, precisarão do Windows
Hypervisor se estiverem trabalhando com máquinas Intel ou se você estiver trabalhando
com a AMD máquinas, você precisa habilitar o
SVM para que isso funcione. Ok, então agora que temos, o terminal do Ubuntu
está aberto, provavelmente
é hora de
executar nossos comandos da CLI. No entanto, não vou executar
esse comando curl, pois
já o
executei e não quero cair no problema de diretórios
duplicados. Você provavelmente deve ir
em frente e executar isso primeiro. Ele deve fornecer a você um C
Cloud instalado depois. E quando isso acontece, tudo o que você precisa fazer é apenas executar um comando simples que
diz ver atualização na nuvem. E ele verificará se há atualizações na nuvem
C para ver se há alguma. Provavelmente deve haver
uma grande atualização para mim, mas não vou
atualizá-la agora. Sim, lá vamos nós. A única atualização é
uma versão principal e não tenho tempo
para isso agora. Vou deixá-lo depois. Acho que é hora de
agora fazer login no número 2. Agora, outra coisa que temos
que fazer de dentro da nossa CLI ou terminal é que precisamos ter acesso ao nosso console
e à nuvem daqui. Para fazer isso, precisamos ter alguns meios de comunicar com nosso
Console e Nuvem. Para se comunicar com
o Console e a Nuvem, você precisa ir para a
integração de dados no lado esquerdo e verá uma pequena guia
aqui que diz chaves de API. Aqui, você pode
criar uma chave de API. Ele lhe dará duas opções aqui. Digamos que você possa ter acesso
global ou
ter acesso granular. Para isso, eu
recomendaria que você vá
para acesso global. Depois de ter acesso global, você pode seguir em frente e usar
essas credenciais para se conectar ao seu cliente,
o terminal Ubuntu. Agora podemos dar a isso mais qualquer descrição em
sua maior parte, eu posso simplesmente chamar isso
de chave de curva de habilidade. Se eu quiser, posso
baixar isso e continuar. Ele até lhe dá este
pequeno texto que dá essa chave se o seu, todos os detalhes da sua chave, fornece um
arquivo de texto com todos eles. Agora que eu tenho e
minha chave de API foi criada, vou
voltar ao meu terminal Ubuntu. Agora atribuído a fazer
login em nosso Console e Nuvem usando os
determinantes da Lua são para isso. Eu só vou
ver nuvem,
login, traço, traço salvar. Agora daqui vai
me perguntar minha credencial confluente. Eu só vou colocá-los em apoio à
taxa de meio-fio qualificado. Assim que
eu colocá-los, ele vai me
pedir minha senha. Vou fazer uma pausa
muito rápido e colocar isso. Ok, então agora que
eu tenho minha senha e vou
pressionar Enter, ele deve me registrar em
meus comps want cloud. E ele escreveu essas
credenciais no arquivo NET RC. Agora que estou conectado ao
confluent, é hora de ver nosso
cluster em uma CLI apenas para que você possa saber que
estamos realmente logados. E é sempre bom
garantir a si mesmo que você
pode ver o cluster. Para isso. Bem, precisamos fazer é
apenas escrever a lista de clusters do
C Cloud Kafka para ver o que podemos encontrar. E, como você pode ver,
só criamos um cluster. E podemos ver o
ID aqui. Portanto, esse é apenas o único cluster que
temos e gostaríamos de
usar esse cluster por padrão. Não queremos ter que
colocar o ID em todas as vezes quando
estamos usando esse cluster. Então, o que podemos fazer para
torná-lo nosso cluster padrão
é que podemos apenas escrever espaço em C Cloud, cluster espacial
Kafka, uso do espaço. E então esse nome, então L, K, c dash z, dois MPs. Lá vamos nós. Ele definiu que
são um cluster Kafka
como o cluster padrão e ativo para o nosso ambiente de trabalho
atual. Ok, então agora que temos nossa configuração de cluster padrão dentro do terminal,
dentro da CLI, agora é um bom
momento para trazer nossa chave de API que
fizemos para que possamos
vincular os dois juntos. Para vincular a chave da API, precisamos escrevê-la
como chave de traço da
API do espaço em nuvem C e armazenar. E o que precisamos armazenar
aqui é a chave da API, que estou apenas copiando aqui
, espace e cole. Depois disso, ele vai me perguntar
se é um pouco
difícil de ver, mas no canto
inferior está dizendo,
qual é o segredo da sua API? Estou copiando esse segredo da
API agora. E lá vamos nós. Agora ele armazenou
o segredo da API e armazenou a chave da
API para eu usar. Agora que tenho uma chave de API, quero dizer à minha CLI, ok, agora para
um determinado recurso, quero usar essa chave de
API por padrão. O que estamos essencialmente
fazendo é fazer com que essa chave de API funcione como padrão para o
cluster que acabamos de definir. Então, para fazer isso, o que temos que fazer é
apenas ver a API da
nuvem dash q0, uso de barra
direta. Na verdade, precisamos dessa
coisinha aqui, como antes. Podemos simplesmente colocar isso. Então podemos fazer traço,
traço recurso. Mais uma vez, podemos simplesmente pegar o nome do
nosso recurso daqui e copiá-lo. E agora definimos nossa chave de API, como a chave de API ativa para um cluster que
configuramos. Com isso feito, agora
estamos basicamente todos configurados para ir em frente e começar a consumir e até produzir mensagens de e para
nosso Console e Nuvem. Agora, para
consumir mensagens, eu recomendaria abrir um novo terminal para Ubuntu para que possamos
vê-lo separadamente. Assim, podemos abrir mais um
desses e levá-los
a decidir aqui. Agora, para consumir
de um cluster Kafka
ou de confluente. No nosso caso, o que precisamos
fazer é escrever um comando e especificar o tópico do qual queremos consumir. Então, no nosso caso, isso
se tornará C Cloud, Kafka, tópico, consumir traço, traço. Desde o início. Em onde especificamos queremos que tudo venha
desde o início. Nós o alimentamos assuntos. Lá vamos nós. Agora você pode ver que temos
inglês, matemática e ciência. Esses são os assuntos
que realmente
colocamos em Kafka nós mesmos. Então essa é a parte empolgante
do Kafka
que fizemos, que fizemos mensagens e agora podemos ver
essas mensagens como um consumidor. Até agora,
vimos que nos conectamos ao nosso cluster confluente,
configuramos mensagens e nosso tópico e
consumimos essas mensagens. Está tudo bem e bom. Mas acho que agora devemos avançar lado do consumidor para
o
site do produtor e produzir mensagens para o nosso cluster. Antes de fazermos isso, de
volta da GUI
dentro do confluent, acabamos de abrir
a página e fomos ao tópico e apenas os
colocamos neste site de GUI
muito legal, mas devemos saiba como
fazer isso a partir da CLI. E se dentro da CLI pudermos
vê-lo funcionando em tempo real. Então, para fazê-lo a partir da CLI, o comando que
usaríamos é C Cloud, espaço,
Kafka, tópico, produzir traço, traço, traço, chave, espaço,
traço, traço, delimitador. Então, além disso, temos dois pontos além do qual
temos o formato de valor. Podemos dizer, para nosso exemplo, já que estamos trabalhando
com strings, podemos dizer que
isso é uma string. E nós apenas especificamos o tópico que, no
nosso caso, está sujeito. Quando pressionamos
Enter, lá vamos nós. Diz que está iniciando
o produtor Kafka. A partir daqui, você pode realmente começar a adicionar,
produzir mensagens. E devemos ver
essas mensagens chegarem ao consumidor
no lado direito
da tela
no momento em que as
produzimos. Por exemplo,
digamos que queremos adicionar mais assuntos. Podemos ir para a geografia. Produzimos geografia. E lá vai você. Ele foi adicionado
diretamente ao nosso consumidor. Dizemos que a geografia é boa em OB, mas também quero aprender
história o suficiente. Lá vamos nós. história apareceu
no lado direito. Então dizemos seis, por exemplo, que agora
isso não é bom o suficiente. Eu queria fazer assuntos internos
ou internos ou assuntos globais. Podemos fazer com que esses
assuntos globais continuem aparecendo. E essa é apenas a
beleza do Apache Kafka. É por isso que é
uma tecnologia tão boa, é que no momento em que
produzimos uma mensagem, o consumidor recebeu a mensagem, o momento e a atualização foram feitas. O consumidor foi alertado
sobre isso, o consumidor sabia disso e poderia consumir as
mensagens atualizadas imediatamente. Com isso,
agora temos um controle sobre
as consoantes CLI. Agora sabemos como funciona. Podemos fazer um produtor, podemos fazer um consumidor
tudo dentro da CLI. E configuramos um
cluster em nosso Confluence Cloud e configuramos um tópico. Fizemos praticamente a maioria
dos fundamentos quando
se trata de trabalhar
no Apache Kafka. Mais tarde, também veremos
como trabalhar com fluxos. E também vamos dar uma
olhada em qual caso é igual a DBS.
7. Introdução ao KSQLDB: Árvore de seção, K SQL DB, introdução ao SQL DB. O que é caso igual a dB? Bem, o K SQL DB é um
banco de dados de streaming de eventos em
tempo real que é construído sobre fluxos
Apache Kafka e Kafka. Agora, o que os fluxos do Kafka são como um tópico que
discutiremos mais tarde. Mas, por enquanto, tudo o que você
precisa entender é isso. A forma como um fluxo é definido
no nível realmente fundamental é o fluxo de dados de um
produtor para um consumidor. K SQL DB usa esse
fluxo e o vincula a um
modelo de banco de dados relacional usando comandos SQL. Existem muitos
casos de uso do K SQL DB, e ele é muito usado
no setor por causa de como é simples e
fácil de usar. Como funciona o case é igual a db? Casey equal db
separa sua camada de
computação distribuída de
sua camada de armazenamento para a qual emprega Kafka. caso é igual ao próprio dB lidou com todas as tarefas
associadas aos dados, seja filtragem,
processamento, streaming, o que for. E então ele deixa o armazenamento para Kafka para
descobrir e gerenciar. Como interagimos com
Casey igual a EB. Embora isso possa ser feito
de várias maneiras, podemos fazê-lo por meio de APIs restantes. Podemos jogá-lo
direto através do código. Ou vamos fazê-lo
da maneira que
definimos neste curso. A primeira maneira pela qual vamos nos
comunicar com o caso igual db é usar o
caso igual db CLI. A segunda maneira de
interagir com o K SQL DB é usar a interface do usuário do Cloud confluente
que vemos no Console. E o Cloud em si.
8. Usando KSQLDB: Usando caso igual db. Ok, então, para
começar a usar
o KSQL dB, a primeira coisa que temos
que fazer é configurar um cluster no qual
estaremos trabalhando. Quando você acessa o console e nuvem na página de
ambientes, você deve estar vendo
algo assim. Caso contrário, talvez um pouco
diferente se você já
tiver 12 clusters configurados. Como não temos
como configuração de cluster, vamos apenas entrar em
nosso ambiente padrão aqui e apenas configurar um cluster. Então, ele diz Criar
cluster por conta própria, basta ir para um cluster básico,
começar a configuração. Você pode definir essa
região para o que
quiser que seja e apenas definir uma única zona e
continuar porque você
verá que o custo base
disso é de US $0 por hora, o que, para esta demonstração, não realmente precisa de
algo muito extravagante. Então, vamos apenas
ir com isso. Então, uma vez feito isso, você pode
simplesmente iniciar seu cluster e ele deve ser iniciado muito rapidamente. E acabou de configurar o cluster que estamos criando o provisionamento de cluster
pode levar um segundo ou dois. Uma vez terminado,
ele vai te dar a tela e
vai dizer olhe, você quer configurar talvez um
cliente ou outra coisa. Você realmente não quer
fazer isso agora, então você pode simplesmente cruzá-lo
aqui e isso deve levar você à visão geral
do seu cluster. Quando você estiver nesta visão geral, você verá um pequeno menu
no lado esquerdo aqui. Agora, para
trabalhar com K SQL DB, é uma espécie de
dado que você precisa um tópico com o qual
brincar, criar tabelas e
fluxos para que tenhamos um meio de obter
informações de e para e temos uma referência que as informações
vão passar. Se formos a tópicos
e não deve haver, sim, nenhuma configuração de tópico aqui. E, claro, seu
cluster estará pronto para uso em um
a dois minutos. Como eu disse, o provisionamento
leva um pouco de tempo. Então o que vou fazer é pausar
o vídeo aqui. Eu vou voltar
do cluster é completamente provisionado e
depois vamos seguir frente e configurar um tópico. Ok, então agora que o
cluster foi provisionado e está me permitindo
criar um tópico. Então, vou seguir em frente
e criar um tópico aqui. Posso chamar esse tópico de qualquer coisa. Para o bem
dessa demonstração, vamos chamá-la de
assuntos. Por que não? Ou podemos simplesmente
chamá-lo de usuários. Porque nos usuários você
pode ter um monte de informações e
geralmente é mais fácil criar um fluxo a partir dele. Então, vou apenas criar
isso com os padrões. E ele
geralmente deve ter tópico
deste usuário pronto para começar
no momento em que você configurar isso. Então, agora que você tem seu tópico, configure-o atribuído para
realmente entrar no seu banco de dados
SQL caso e configure
um
aplicativo de banco de dados igual a casos que vamos usar para manipular esse tópico e
realmente trabalhar com ele. Então, o que você vai
para o caso igual a VB? Sim. Ele dirá que lhe dará
a capacidade de criá-lo com o tutorial
ou você mesmo pode criar o aplicativo. Vamos apenas ir em
frente e criar o aplicativo nós mesmos, dar um acesso global, Continue. Você pode chamá-lo do
que quiser para definitivamente fazer uma
diferença cega. Vou
usar o menor tamanho de
aplicativo para
que não haja muito custo no meu
console e na nuvem. E vou
lançá-lo. Agora você deve saber, neste
momento, que a configuração aplicativos de banco de dados
iguais
leva um pouco mais de tempo. Na verdade, leva
muito mais tempo do que provisionar um cluster
Kafka confluente. Esse processo deve
levar de quatro a cinco minutos. Então, o que vou fazer
agora é
pausar o vídeo aqui e
voltar quando terminar de provisionar
o aplicativo DB igual ao caso. Você pode ver que,
quando terminar de provisionar seu
aplicativo de banco de dados igual caso, você pode encontrar um erro no
qual o cluster diz, não
consigo me conectar a
esse aplicativo de banco de dados SQL caso. Você não precisa entrar em pânico. Isso ainda faz parte
do provisionamento. Assim que o
provisionamento estiver concluído, esse erro deve
desaparecer por conta própria. Agora
que temos isso, esclareça, vou pausar
o vídeo agora, deixar essa provisão e
voltar quando tudo estiver pronto. Ok, então nosso
aplicativo de banco de dados igual a casos agora está funcionando. Ele foi provisionado. Assim, podemos entrar e dar uma olhada rápida e você
pode ver como, por dentro, é
assim que um aplicativo
DB igual será. Você terá um editor
aqui que permitirá que você execute suas consultas SQL nele. E então, ao lado dele, você
verá a guia de fluxo, que mostrará exatamente
como as coisas estão funcionando, quais fluxos estão
se alimentando, quais tabelas estão alimentando
em que fluxo, assim por diante e assim por diante. Você pode ver seus fluxos, a lista de todos os fluxos, neste caso, o aplicativo de banco de dados igual aqui, eles listarão todas as suas tabelas, bem
como suas consultas. Além disso,
você pode ver, uau, seu aplicativo de banco de dados igual ao caso está indo
com o desempenho. Você pode verificar
diferentes configurações para seu aplicativo DB igual ao caso. Você precisaria conhecer algumas
dessas configurações caso
queira se conectar a elas. Por exemplo, esse
endpoint aqui você costuma usar um
endpoint para se conectar a aplicativos db iguais a casos quando você tiver que trabalhar com
k é igual a EB. Por fim, você terá instruções de
CLI
no final que
permitirão que você faça login no banco de dados
igual a casos e faça login no Console e na Nuvem
e use seu aplicativo de
banco de dados igual a caso da CLI. Agora que temos esse caso
é igual ao aplicativo de banco de dados em execução, é hora de gerar algumas informações em nosso tópico
e, em seguida, fazer alguns fluxos e tabelas a partir dessas informações. Então, vamos voltar à
nossa visão geral do Cluster. Agora vamos ver
como podemos gerar algumas informações sobre
nosso tópico de usuários. Kafka realmente tem uma coisa
bem legal se você quiser gerar
informações ou mensagens em um tópico é
que ele tem um monte de
geradores de dados pré-fabricados que
continuarão enviando
informações para um tópico se for necessário
configurar um gerador de dados, o que vamos fazer é
entrar na Integração de
dados e
ir para conectores. Quando você entrar em
conectores aqui, você verá todos esses
conectores aqui. Estamos à procura de geração de dados, então vamos apenas
pesquisar a fonte de geração de dados e isso
é de Ladin Kafka não é um terceiro, então não vai ter problemas
na configuração. Agora que você está aqui, você tem que montar um monte de coisas. A primeira coisa, é claro, é o nome do conector da
fonte de geração de dados. Bem, justo o suficiente, realmente não
importa. Podemos usar uma chave da API Kafka
para conectar-se ao nosso conector. Então, temos uma
configuração de chave de API neste momento, não
precisamos nos preocupar
com problema porque
temos um pequeno link aqui que gerará
uma chave
e segredo da API do Kafka para nós em tempo real. E o que podemos fazer é clicar nele. E lá vamos nós. Ela nos deu uma
chave de API e um segredo. Podemos simplesmente chamar isso de
nossa chave de geração de dados. E ele fará o download dessa chave
como ela é feita ali. E isso vai colocar
as credenciais para você. Você não precisa
passar por nenhum problema e não
há risco de cometer um
erro inserindo isso. Agora temos isso feito. Você precisa passar para tópicos. Nosso tópico são usuários ali mesmo. Agora você tem que escolher suas mensagens
de saída para que
possamos dizer Dê-nos os
valores e JSON. Por fim, essa é
a parte
importante que diz
detalhes de conjunto de dados onde você precisa escolher agora qual modelo de informações você
deseja alimentar em seu tópico. Se você abrir este menu suspenso, verá apenas um monte de dados diferentes
Jens disponíveis para nós. Temos fluxo de cliques,
códigos de fluxo de cliques , cartões de crédito do usuário, inventário, pedidos, pagers, compras de
produtos, classificação,
assim por diante e assim por diante. Mas o engraçado é que há um jato de dados aqui
exatamente para os usuários. Então, o que vamos
fazer é clicar nesses Dados, Jen, e vamos definir um padrão
do valor padrão de suas
mensagens que são enviadas,
que é basicamente o
intervalo entre as mensagens. É enviada uma mensagem, quando ela envia a próxima? Por padrão, os valores 1000. Então, se você deixar isso
completamente vazio, o que
ele vai fazer é
continuar enviando mensagens a cada segundo ou a cada
100 milissegundos. Então, vou
deixar isso por enquanto. Quero colocar 1000 aqui
para mostrar que ele
vai enviar mensagens
após cada segundo. Mas mesmo que eu não faça isso, ele ainda enviará
mensagens a cada segundo. Então, se você planeja
mantê-lo assim, você pode deixar
esse campo vazio. Estou deixando, estou colocando o valor aqui apenas para que saibamos que definimos esse valor de 1 segundo
para cada mensagem. Agora, depois que isso for feito, podemos passar
para o número de tarefas que esse conector
tem permissão para executar. Agora, com cada tarefa, o custo da execução
do conector aumenta. Você verá que, se você escolher
mais de um conector, precisará atualizar sua conta confluente
para que mais tarefas funcionem. Então, não vamos entrar em que uma tarefa é suficiente
para este exemplo. Então, vamos
fazer uma tarefa. Vamos deixar todo o resto e
vamos em seguida. Quando você fizer isso, ele
vai te dizer, olhe, para cada hora de tarefa, ele
vai cobrar tanto. E para cada GB
de dados que você usar, ele vai cobrar tanto. Você tem US $400 em sua
conta de avaliação com confiança. Então, realmente executar isso
por alguns minutos não será um
problema algum. Portanto, não se preocupe muito com o custo de funcionamento
disso e apenas o lançamento. Ao lado do
botão Iniciar,
é claro, há uma visualização de dados
que permite que você veja que tipo de informação
você estaria recebendo. Mas eu gostaria de mostrar isso
no tópico em si, ao
invés de mostrá-lo lá. Então, agora que você tem
um conector principal, ele será
provisionado por alguns minutos, assim como o
caso igual a dB. Então, o que vou fazer é pausar o vídeo aqui, voltar quando for
provisionado e depois mostrarei as informações
que ele é
alimentado no tópico. Ok, então configurar
meu conector para minha geração de dados estava demorando
mais do que eu esperava. E eu assumi que era porque eu tinha usado esse nome
antes e eu tinha um cliente que já estava conectado a esse nome de
conexão dela. Eu tive que voltar, excluir
o gerador de dados que
fiz e criar um novo chamado
Meu pai fez gerador de dados. E agora que isso está
funcionando, vamos entrar e
ver o que está fazendo. Se você entrar no meu gerador de
dados, verá que é, bem até agora ele
produziu 82 mensagens. E tem aquela tarefa andamento que está sendo executada,
apenas vai fechar essa pequena informação
aqui que está me
dizendo que meu
gerador de dados está sendo executado. Se você entrar nas configurações, verá toda a configuração
que você deu a ela. Você pode até
voltar e alterar essas informações se precisar, mas eu não recomendaria porque
isso poderia fazer
com que seu
fluxo fique cheio de turvy. Todas as suas configurações
teriam que mudar acordo e
seria apenas uma bagunça. Portanto, eu não recomendo
que você faça alterações a isso, a menos que seja
absolutamente necessário. Agora que sabemos como o gerador de
dados está funcionando, vamos analisar nossos tópicos. Sim, vamos
ao tópico do nosso usuário. Mas antes disso podemos
ver que um tem um valor associado agora dentro de
seu campo de produção, o que quer dizer que este tópico está realmente recebendo algo. O que é isso, vamos
entrar e dar uma olhada. Se entrarmos em mensagens, deveríamos estar vendo
quais mensagens foram produzidas aqui. Então, à medida que você chegou aqui, agora
ele mostrou as
mensagens que
até agora foram geradas para o tópico
desse usuário. E lá vai você. Você acabou de receber outro. Se abrirmos este último, você pode ver que
na verdade há vários valores associados a uma mensagem. Então, se
olharmos para os valores aqui, temos o horário registrado, o ID do usuário, o
ID da região e o sexo. Se entrarmos no cabeçalho,
podemos ver o que,
como a chave foi
gerada, o ID da tarefa, a iteração
atual e a
última, mas não menos importante, que é a chave
para esta mensagem, que é o sublinhado do usuário três. Temos esses dados
sendo gerados agora em nossos tópicos
para que possamos seguir em frente e a decadência é igual
a db e configurar um fluxo para esses dados. Então, vamos para o aplicativo. Agora podemos realmente configurar um
fluxo do editor aqui. Vou fazer
o fluxo à mão para que eu
possa explicar cada elemento do fluxo à
medida que formos fazendo isso. Então, a primeira coisa que temos que
escrever é criar fluxo. Na verdade, se você estiver no Create, verá que ele
oferece duas opções. Quando você cria fluxo, você pode ver que ele oferece
várias opções aqui. Então, se você simplesmente
criar stream isso, então podemos simplesmente chamar esse
stream o que quisermos. Poderíamos chamá-lo de nossos
usuários sublinhando extremo. Agora temos que dar a ele os
campos que ele tem que tomar. O que podemos fazer por
isso é que podemos
entrar em tópicos, usuários, mensagens, e podemos apenas dar
uma olhada básica em quais mensagens temos dentro desta escolha qualquer uma dessas
mensagens, abri-la. Podemos ver que
registramos o horário. Ele já alcançou
uma identidade e gênero. E estes vão
entrar onde ocorrer. Isso vai entrar, creio
eu, um grande int. Então eu vou colocar isso em um grande int
e espero
que não vai cair
comigo como eu faço isso. Vou abrir um bloco
de notas aqui. Vamos apenas
armazenar essas informações em um bloco de notas aqui. Então, quando volto ao caso
igual db e configuro meu fluxo, mas agora podemos criar
stream, fluxo de sublinhado do usuário. Podemos dar-lhe
tempo registrado como um grande int. Podemos dar a ele um ID de
usuário como trabalhador, onde podemos dar a
ele um ID de motivo, que também é um trabalhador. Por fim, podemos dar um gênero, o que também ocorre. Quando você tiver feito isso, você definiu quais campos
irão para o fluxo. Agora você tem que dizer de qual
tópico ele receberá essas informações e qual será o formato
de valor. Então agora vamos colocá-lo
com sublinhado de Kafka. O tópico é igual a, podemos dizer que os usuários. E podemos dizer que o formato de
valor
será o formato
de sublinhado será JSON. Agora que fizemos isso, podemos apenas colocar um ponto e vírgula
no final dele. Podemos definir isso como o mais antigo, o deslocamento automático redefinir mais cedo para que ele obtenha os valores desde o início da existência de
tópicos, por assim dizer, e
apenas executar a consulta. Lá vamos nós. Então, se isso for executado para
o sucesso do status, o que significa que
criamos nosso fluxo. Se funcionou para você,
você pode ir até seu
fluxo e você deve ver uma nova configuração de fluxo aqui chamada fluxo de sublinhado
do usuário. E se você abrir o fluxo de
sublinhado do usuário, bem, isso não está
nos mostrando nada aqui, mas se formos aqui e
consultarmos o fluxo
assim com o mais cedo, devemos receber algumas mensagens. Sim, lá vamos nós. Na verdade, estamos recebendo uma
quantidade razoável de mensagens. Mas, novamente, ele está recebendo todas as mensagens
desde o início. Então, vai levar
seu tempo e vai nos
dar todas
essas mensagens. Se quiséssemos equilibrar, podemos até interromper essa
consulta a qualquer momento. Lá vamos nós. Agora podemos usar qualquer coisa
que tivermos daqui. Então, todas essas
informações que temos, nós a temos em nosso fluxo. Está indo agora,
configuramos um fluxo. Se passarmos para nossa integração de
dados e passarmos para os clientes, podemos ver que realmente
temos um produtor de conectores e uma configuração de consumidor que está realmente levando todas essas informações se
você for para tópicos, sim, ele está tirando dos tópicos
do usuário. Portanto, seu fluxo está
funcionando agora como produtor
e consumidor. E se você passar para
sua linhagem de stream, verá que seu gerador de
dados está gerando informações para os usuários do tópico, que serão consumidos
por esses dois consumidores, seus aplicativos personalizados , se você quiser, que estão consumindo
as informações. Agora que fizemos isso,
configuramos um fluxo. Agora vamos seguir em frente e ver como podemos configurar uma mesa. Então, vamos seguir em frente e fazer isso. Então, vamos para o
caso deles aplicativo de banco de dados igual novamente. Do nosso caso, o aplicativo
DB é igual novamente. Agora, em vez de agora ele tem uma configuração de consulta para você
pronto para selecionar estrela do fluxo de usuários e emitir as
alterações onde ela mostraria tudo o que estava
dentro do fluxo do usuário. Mas não queremos
fazer isso agora. Queremos ir em frente
e criar uma tabela. Então, o que vamos fazer
agora é que vamos nos
livrar dessa consulta que
eles nos deram. E dizemos que crie uma tabela. Podemos simplesmente chamar
o mesmo comprimento. E assim podemos chamar a tabela sublinhada desse
usuário porque estamos usando
o mesmo tópico. Não estamos mudando
muito de nada aqui, então podemos simplesmente chamá-lo de ID de usuário. Onde se preocupe,
porque é uma mesa. Se você conhece o SQL básico,
sabe como ele funciona. Você precisa associar uma chave primária às
tabelas criadas. Então, vamos definir
nosso ID de usuário como a chave primária para esta tabela, que é o identificador
para cada linha que nos permite saber que ela é única e
não foi repetida. Assim, podemos definir o horário de registro. Grande int. Novamente, vou dar
um grande gênero int como Barker, o trabalhador de identificação da região disse que a
largura igual ao tópico de sublinhado do
Kafka atribuído é igual aos usuários. E o formato de valor, novamente, enquanto você sublinha, enquanto o formato de sublinhado
se torna JSON. Lá vamos nós. Então podemos simplesmente colocar
isso no final,
no ponto e vírgula e
executar a consulta. Lá vamos nós. E isso nos deu
uma mensagem de sucesso, o que significa que nossa
tabela foi criada. Então, agora, se formos
ao nosso flutuador novamente, agora veremos que
temos uma tabela de usuários, configuração de
tabela para nós. E se entrarmos na tabela, podemos entrar aqui
e consultar a tabela. Se entrarmos em R, se executarmos a consulta, veremos que ela já tem todas essas informações dentro dela, que são obtidas do tópico. Tudo o que tínhamos que fazer era configurar uma tabela contra o tópico e isso gerou
toda essa tabela para nós. Eles acabaram de sair do bastão. Não precisávamos fazer mais nenhuma
configuração do que aquela linha de SQL que tivemos que escrever
para configurar essa tabela. Com isso, você
efetivamente criou um bom fluxo,
bem como uma tabela. Com isso, configure efetivamente um aplicativo de banco de dados igual a casos, bem como um fluxo e uma tabela e um tópico para o qual os dados
estão sendo gerados. Dois. Agora você sabe como
configurar esses elementos no Confluence Cloud
e continuar com eles.
9. Visão geral dos fluxos Kafka: Seção para fluxos Kafka. Visão geral dos fluxos Kafka. O que nossos fluxos Kafka. Bem, se você
olhar para os fluxos do Kafka, é basicamente apenas uma biblioteca
Java que nos ajuda a fazer o que essencialmente estamos fazendo até este ponto. Mas de uma maneira muito mais fácil. Streams define
o fluxo completo de produtor para
tópico para consumidor. E permite que você
crie esse fluxo com código
significativamente menor do que você
precisaria , caso contrário, se você estivesse
fazendo isso de forma diferente. Os fluxos Kafka são extremamente tolerantes a
falhas devido à natureza distribuída
dos clusters Kafka. Também poderíamos dizer que os fluxos têm essa propriedade
distribuída. Considere o
exemplo a seguir de como você cria um consumidor e um
produtor em um programa. Primeiro você teria que
criar o consumidor, então você tem que
criar o produtor, assinar o tópico, que neste caso
são widgets e tirar seu
registro de consumidor, o que no nosso caso, isso vem à cor vermelha. Só queremos que um consumidor consuma essa mensagem que
os produtores vão enviar, que temos um legítimo que
é da cor vermelha. Agora considere esse código. O engraçado é que
você pensaria que essas quatro linhas não são completamente diferentes do que
você acabou de ver antes. Ou eles podem complementar o código que você
acabou de ver antes disso. Mas, na verdade, ele faz
a mesma coisa. Ele simplesmente abstrata toda essa programação e
tira muita daquela
casa de você. E ele apenas coloca tudo
isso em um fluxo. É assim que os fluxos podem codificar concisa e fácil de
trabalhar para desenvolvedores. Embora possa ser bom e
bom que os fluxos do
Kafka nos dê a capacidade de escrever
código mais longo e forma mais curta. Por que devemos
usar fluxos Kafka? Enquanto no final do dia, os fluxos do
Kafka são mais do que simplesmente tornar o código conciso. Os fluxos nos permitem executar
determinadas tarefas em nossos dados, tarefas de
dados que não poderíamos
executar de outra forma, como filtragem,
juntar uma agregação. Essas são tarefas que
queremos que nossos fluxos façam porque queremos que nossos
dados se tornem mais significativos para o consumidor final
por meio de fluxos Kafka. Bem, nós realmente conseguimos à medida que pegamos os
dados que estão sendo produzidos e consumidos e
damos muito mais significado. Então, esse é realmente
analisado e analisado. Podemos fazer
entendimentos adequados desses dados e, possivelmente, até usá-los para painéis e para
análises mais tarde.
10. Introdução ao Kafka Connect: Seção para Kafka Connect. Introdução ao Kafka Connect. O que é o Kafka connect? Bem, com o Kafka Connect é
competente do Apache Kafka, e é provavelmente o mais importante
competente do Apache Kafka. Se você planeja usar serviços
Kafka e AT com uma configuração que você
já possui. Catholic
Connect permite que você conecte seu cluster Kafka e seus serviços Kafka a uma
variedade de serviços diferentes. Ele tem conectores para a maioria dos serviços de
dados por aí. Seja
Amazon, GCP, Hadoop, Kafka Connect fornece integração de
streaming entre o Kafka e
outros serviços. E permite que você
conecte ambas as fontes, bem como sincronizações de dados ao
seu cluster Kafka. Você pode ter dados provenientes de uma fonte de dados para
o cluster Kafka. Por que uma conexão católica? Ou você pode ter dados indo do
cluster de capital
para um coletor de dados. Por que um Kafka conecta
essa sincronização
de dados , é claro, estar em um
serviço que não é Kafka. Agora, no nosso caso, para o projeto que
vamos fazer, vamos configurar um coletor de
dados no Amazon S3. Agora, quais são os
casos de uso do Kafka Connect? Enquanto discutimos
anteriormente, Kafka Connect permite que
você se integre serviços
externos que já
estão sendo usados. Você já tem dados sobre esses serviços e
seria inútil ir em frente e criar um novo
cluster e depois preencher esse cluster com todas as informações
que você já tinha. Em vez disso, é mais fácil apenas se conectar com o que você
está acontecendo atualmente. A segunda coisa é católica e fornece o que é basicamente uma integração perfeita com seus serviços em sua maior parte. Você só precisa
configurá-lo principalmente na GUI. E você
realmente não tem muitos problemas em termos
de configuração. Se você decidir como
deseja esses dados, qual forma de dados deseja. E isso é isso
na maior parte. O último grande benefício de usar o
Catholic Connect, ele abre muitas oportunidades no domínio do streaming
de dados para você. Então, agora você pode fazer
esse fluxo de dados funcionar e você pode realmente
executar consultas nele. Você pode transformá-lo em
fluxos e
transformá-lo em dados
muito mais significativos do que antes. Sim, há muitos usos
para o Kafka Connect e
vamos explorá-lo em nosso segundo projeto
neste curso.
11. : Ok, então para começar esse
projeto, vamos ter uma visão geral do que vamos
fazer hoje. Então, a primeira coisa que
vamos
fazer é criar um produtor em Python que irá produzir nossas
mensagens para o nosso tópico. A segunda coisa que vamos
fazer é
avançar em nosso conjunto de
consoantes. E vamos criar
um tópico que receberá nossas mensagens
do produtor. Assim que tivermos essas
duas coisas configuradas, publicaremos mensagens em
nosso tópico para que possamos preenchê-lo bem para quando
criarmos nosso consumidor. Depois disso, vamos seguir
em frente e configurar nosso consumidor. E então estaremos
prontos para começar a consumir mensagens do nosso
tópico Kafka dentro do confluente. Vai ser um
projeto muito simples, não muito técnico. Então, sem mais delongas,
vamos entrar nisso.
12. : Agora é hora de
ver como configurar nosso produtor em Python. Porque agora que temos toda a
nossa configuração
pronta para começar, é hora de criar nosso produtor
que produzirá as mensagens
para nós em nosso cluster Kafka. Para isso, vamos criar
um novo arquivo aqui. Podemos chamá-lo de produtor
ponto p-y. Lá vamos nós. Então, agora temos um
arquivo de produtor pronto para uso. Vamos abrir nosso produtor. Bom, certo, Esses guias de
boas-vindas. Agora, para este produtor, há um pouco de código que
eu já estou escrito para você. Vou
colar isso aqui e explicar para
você o que ele faz. Este bit superior do código aqui, tudo o que ele faz é que ele analisa a linha de comando e
analisa a configuração. O que isso significa é que está
apenas tentando descobrir para qual cluster eu tenho que
enviar minhas mensagens. Faça. Na verdade, tenho uma chave de API
que me permite fazer isso. Eu tenho o
segredo correto, assim por diante e assim por diante. Então esse identificador, tudo isso apenas
neste analisador de conflitos. Depois disso, além disso, temos um produtor
que estamos criando. Uma instância do. Dizemos que temos um produtor
que é um produtor de café. Agora, depois disso, não estamos
tentando enviar mensagens. Quando nós, quando enviamos mensagens, muitas vezes
existe
a
possibilidade de que a mensagem não seja enviada
por qualquer motivo. Portanto, no caso de acontecer, temos um
método de retorno de chamada de entrega que diz, ok, se você tiver algum problema, imprima a mensagem de erro e diga ao usuário
qual era o problema. Caso contrário, se você
conseguiu enviá-lo,
diga ao cliente
ou ao usuário que ei, eu produzo seu evento, um tópico, seja qual for o seu tópico com
essa chave e esse valor. Agora, se você chegasse
ao fundo aqui, esta é a nossa carga útil, linhas 34 a 36, onde nosso tópico são livros. Temos um monte de IDs de usuários
contra vários produtos. Como vamos
criar mensagens? Está bem aqui das
linhas 38 a 44, onde acabamos de tomar
um intervalo de dez. Para dez mensagens,
estamos
alocando aleatoriamente um ID de usuário para um livro. Por exemplo, poderia
ser Jack e crepúsculo, poderia ser Michael
e Senhor dos Anéis, pode
ser Hannah e Aragon. E alguns deles podem até
acontecer duas ou três vezes. É completamente aleatório, mas receberemos dez
mensagens dele. Este é um produtor muito
simples, muito fácil, muito leve que produzirá dez mensagens para nós para o nosso
cluster Kafka em nosso tópico. Vamos salvar esse
arquivo e fechar.
13. : Ok, então agora que temos
nossos produtores configurados, é hora de criar
esse tópico para o qual dissemos que
vamos produzir nossas mensagens para
o produtor. Agora que temos
nossa configuração de produtor, é hora de seguir em frente
e fazer nosso tópico. Então, vou abrir uma nova janela aqui
e deixar-nos ir
ao confluente e criar esse tópico para o qual
enviaremos nossas mensagens. Vamos fazer login em nosso
console e na nuvem. Lá vamos nós. Então, vamos para
o nosso cluster. E daqui podemos
entrar em tópicos do lado esquerdo. E aqui
devemos ver nossos tópicos. Agora, como você pode ver
no momento, não
temos um conjunto de
tópicos para livros, então só precisamos adicionar
esse tópico imediatamente. Podemos simplesmente chamá-lo de livros como fizemos em nosso programa. Uma vez que dissemos que a criação,
boom, ela é criada, não
há atraso
para essa criação. Agora essa configuração, tudo o que podemos fazer, ou o que realmente precisamos
fazer agora é avançar.
14. : Agora que nosso tópico está pronto
e pode receber mensagens, é hora de produzir
mensagens para o nosso tópico. Fazer na produção de mensagens para o cluster do Kafka usando o método que estamos usando hoje é realmente bem simples. Vamos passar por mais de dois. Vamos passar
para o nosso diretório de projetos. A partir daí, entramos em nosso ambiente virtual usando o bin activate do ambiente de
origem. Agora, há outro passo
extra que temos que fazer aqui porque criamos
nossos arquivos no Windows. Unix não
gosta muito desses arquivos. Você precisa fazer uma
pequena conversão usando os comandos DOS para Unix. Então, fazemos o
produtor DOS Unix dot p-y para Unix, config dot Iodede. Uma vez que fizermos isso, podemos
CH mod nosso arquivo produtor, u plus x, produtor dot PY. E agora podemos administrar nosso produtor. Lá vamos nós. Ele produziu eventos
para livros de tópicos. Dizemos que Jack levou Aragon, Jack levou o livro de Harry Potter, Animal Farm, Michael
para Animal Farm, assim por diante, assim por diante. Só temos dez
chaves e dez valores, dez mensagens que enviamos ao nosso tópico dentro do
nosso cluster Kafka.
15. : Agora que
produzimos mensagens para o nosso tópico e ele é preenchido, é hora de configurar um consumidor para consumir essas mensagens. Configurar um consumidor
é muito simples. Tudo o que temos que fazer é
passar para o nosso projeto Python, criar um novo arquivo. Podemos chamar esse arquivo
consumidor ponto p-y. Depois de fazer isso, basta ir para dentro e colar esse pedaço de código que você deve encontrar na descrição. Este é um
consumo muito simples, realmente básico que
vamos fazer se mensagens
do cluster Kafka. Então, a primeira coisa que
vamos fazer, é claro, como estávamos fazendo
com o produtor, apenas analisando a configuração
na linha de comando. Depois disso, estamos apenas criando
uma instância de consumidor. E à medida que
criamos essa
instância do consumidor, queremos que ela escolha
mensagens do topo, desde o início
de todas as mensagens. Dissemos o offset, basicamente,
que é o que estamos fazendo aqui. Definimos o
deslocamento de redefinição e o
levamos até o início. Então isso é compensado começando
todo o caminho até a parte de trás. Depois disso, estamos nos
inscrevendo no tópico. Temos nossos livros
de tópicos, é claro, como fazemos
para o produtor. vez, em um sinal redefinir compensações. Então, à medida que nos inscrevemos,
vamos todo o caminho de volta. Agora, o que acontece a seguir
é, na verdade, um
processo contínuo até que seja
interrompido onde estamos constantemente tentando e verificando. Se tivermos uma mensagem
esperando por nós. Se o fizermos, obteremos essa impressão do evento consumido de tópicos, assim por diante e assim por diante. Se não o fizermos, apenas
recebemos esta mensagem esperando e, se
encontrarmos com um erro, receberemos essa mensagem de erro. Este último bit é apenas
a interrupção do teclado onde dizemos que se você
quiser parar isso, você pode controlar C e ele terminará. Trata-se de
um consumidor tão
básico quanto você pode obter. E configuramos nossa assinatura de tópicos
dentro de nosso consumidor. Então matando dois pássaros
com uma pedra lá.
16. : Agora que nosso consumidor
está configurado e pronto em nosso tópico tem as mensagens
preenchidas. É hora de
consumir mensagens e ver como esse consumo se
parece em tempo real. Além disso, produzir e consumir mensagens em tempo real é um processo bastante simples. Novamente, porque novamente,
criamos nosso arquivo
PY ponto consumidor dentro do Windows. Temos que converter isso
para um unix para lê-lo. Então, apenas dizemos, ouça, precisamos que você mude
nosso ponto de
consumo para o outono de leitura Unix. Então, agora que fizemos isso, você pode
apenas mudar nosso consumidor. Agora podemos executar nosso ponto de
consumo p-y. Com o conflito. Lá vamos nós. Nosso consumidor realmente recebeu todas as mensagens
que enviamos do nosso produtor mais cedo
e, como as lemos agora, outra coisa legal
sobre isso é que
podemos realmente fazer
isso em tempo real. Então, digamos, por exemplo, eu dirijo meu produtor do lado. Então eu digo que dirija
meu produtor aqui. No momento em que essas
mensagens foram produzidas, o consumidor
as recebeu e
as consome na ordem exata em
que foram produzidas. E se o
executarmos novamente, veremos novamente. Mas isso não é a coisa mais
interessante. O mais
interessante é que se você fizesse essas mensagens
em tempo real, ainda as veria e ainda
poderá lê-las. Agora vamos ao
nosso console e fluir. Mova esta janela para o lado. Vamos analisar nossos
tópicos e ir aos livros. E como podemos ver, temos alguma produção
acontecendo aqui. Ele vê que temos atividade. Se formos produzir
uma nova mensagem, podemos chamá-la de qualquer coisa. Podemos dar a ele um valor, digamos, um bom valor de volta para o futuro. Mesmo que isso não seja
um livro, é um filme. Eu me afligo. Podemos deixar os
ácidos-chave e no momento em
que você produz essa mensagem, boom, você recebe essa mensagem
em seu consumidor em tempo
real que temos um evento com o valor de volta
para o futuro e a chave 18. E com isso, você
tem um trabalho
criado com sucesso um aplicativo que
produz e consome eventos ou mensagens usando confluent
e Apache Kafka.
17. O Project2 PacMan: visão geral: Então, aqui está uma breve visão geral do que veremos em nosso aplicativo que o
torna um aplicativo de streaming. Então, a primeira coisa que
vamos ter
é que teremos dois tópicos, perdas de jogos de usuários e usuários. E esses dois tópicos
serão a base sobre a qual vamos
criar dois fluxos. Esses dois
fluxos alimentarão suas informações
em duas tabelas. O fluxo
de perdas do usuário alimentará suas informações nas
perdas por tabela de usuários. Isso está disposto a
registrar quantas vezes você perdeu todas as
suas vidas no jogo. Estes são o fluxo
de jogos que vai alimentar suas informações nas
estatísticas por tabela de usuários, onde ele registrará
sua pontuação mais alta e quantas vezes você
realmente jogou o jogo e perdeu isso informações de quantas vezes você perdeu o jogo serão alimentadas através de suas perdas por tabela de
usuários em suas
estatísticas por tabela de usuários. Finalmente, essas estatísticas por tabela de
usuários serão consultadas para gerar
o placar que mostra não
apenas sua pontuação, mas as pontuações de todos
que jogaram o jogo. Assim, você pode comparar
suas estatísticas com todos os outros
que jogaram o jogo.
18. Projeto2 PacMan: de Configurar e executar: Como eu uso o Windows
Subsystem para Linux, ele me permite
entrar diretamente
no diretório do meu projeto no meu Windows e ver
os arquivos como eles são. Assim, como podemos ver nosso aplicativo Pac-Man de
streaming, podemos ver que temos vários arquivos e
pastas aqui. A primeira coisa que temos que fazer é entrar em nosso arquivo de conflito, que devemos ter
um CFG de ponto de demonstração. Se abrirmos
isso, ela deve ter nossa chave de acesso
da AWS e
nossa chave secreta da AWS ali mesmo. Agora, o que é isso é o acesso que você define
à sua conta da AWS. Onde você encontrará
sua chave de acesso da AWS
em sua chave secreta da AWS? Bem, vamos
em frente e ver isso. O que vamos fazer
é minimizar isso, chegar à nossa AWS
e apenas pesquisar o IAM. E depois vá para aqui. Quando estiver aqui,
você pode olhar para os usuários em seu Gerenciamento de
acesso. Então você pode simplesmente
ir até os usuários. E a partir daqui você
pode adicionar um usuário. Quando você adiciona um usuário, você pode fornecer o nome defini-lo como
chave de acesso em vez de senha, o que
lhe atribuirá um ID de chave de acesso e uma chave de acesso secreta. Então, se eu adicionar novos usuários, chame-o de curva de escala. Vá em seguida. Você pode adicioná-lo a um grupo de
usuários para administradores. Ou, se você não tiver essa configuração como não faria se
tivesse uma nova conta, você pode simplesmente criar um grupo, atribuir acesso de administrador de TI e chamá-lo de grupo de usuários
administradores. Selecione-o e, em seguida,
basta mover as próximas duas tags e você
pode simplesmente adicionar qualquer chave aqui. Posso chamar essa chave de filtro. Isso é tudo que eu preciso. Honestamente. Eu posso apenas atribuir
o mesmo valor a ele. Basta ir Next. E ele
criará esse usuário. No momento em que fizer
isso, ele lhe dará essa página de sucesso e
permitirá que você baixe como CSV as
credenciais para seu usuário. Além disso,
ele também mostra ID da chave de
acesso e sua chave de acesso
secreta. Tome nota disso porque você precisará deles
para este projeto. Eu recomendaria que você
baixe o CSV. Então, quando você abrir, ele lhe dará exatamente
o que você precisa. Sua chave de acesso é, opa. Ele deve apenas fornecer sua chave de
acesso e sua chave de
acesso secreta aqui, que são as
coisas que você precisa para alimentar sua configuração. Já tenho uma
configuração de conta na minha configuração, então não vou alimentar
essa nova chave de acesso
e chave de acesso secreta dentro dela. Só vou passar para
a próxima coisa. Vou fechar isso, salvá-lo como um só e seguir em frente. Agora que isso está feito,
vamos voltar para nossa pasta e voltar para
o nosso arquivo. Nosso CFG de ponto de demonstração é bom, então vamos
fechar isso e agora estamos voltando ao
streaming do Pac-Man. A próxima coisa que vamos ter que
ver é nossa pasta de configurações de pilha. Precisamos ter certeza de
que não há nada dentro da pasta de
configurações de pilha porque essa configuração
será o que o Terraform usará para configurar
todo o aplicativo. Na primeira vez que você
executar o script de início, enquanto estou prestes a executar, você verá
que ele vai
criar muitas coisas para você. E, na próxima vez que
você executar esse script o formulário de
inverno vai realmente provisionar e criar
todos os recursos. Agora, o que podemos fazer é
ir até o nosso terminal. E a partir daqui
podemos apenas entrar em nosso projeto Pac-Man de streaming e apenas executar nosso script de início. Então, se você
ainda não fez isso primeiro, você teria que
CH mod u plus x. Seu ponto inicial SH
loops u mais x. e então você pode fazer o mesmo
para o ponto parado SH. Você pode fazer o mesmo para
Criar caso igual db app.js. Esses são os três
arquivos shell que você precisa para dar a si mesmo as
permissões para executar. Agora que você fez isso,
tudo o que você precisa fazer é apenas executar o
comando start, Start shell. Então, basta executar start dot SH. E lá vamos nós. Só vai correr para você. E isso vai
te dar esse aviso. E vai dizer
que Olha, ouça, isso vai
criar recursos que vão
custar alguma coisa. Então você tem certeza de
que deseja prosseguir? E porque temos que,
vamos apenas dizer sim, não
queremos prosseguir.
Enquanto o script está em execução. Vou voltar aqui
e voltar à nossa página do S3 porque, uma vez que terminarmos de
executar nosso script, vamos ver
um bucket do S3 criado aqui. Também. Só vou entrar na nossa
página de ambientes no nosso console pensando e ela já está configurada. Isso é realmente meio arrumado. Ele já configurou um ambiente
constante para você. Podemos ver isso aqui, criando conflitos CloudStack
para ambiente e definir o cluster Kafka e o cluster
ativo para ambiente E e nós ECD em 23. Podemos realmente verificar isso. Então, o que podemos fazer é
abrir um novo terminal. Deixe-me ver a lista de
ambientes em nuvem. No entanto, você pode ver o ENV ZD e 23 é nosso Pac-Man de streaming e ambiente
público que
acabamos de criar para
este aplicativo. Então vou deixar isso
correr e voltarei. Quando isso começar. A Shell realmente
terminou de ser executada. Isso leva até
cinco a dez minutos. Ok, então o script de inicialização
terminou de ser executado. E o que é feito é, deixe-me levá-lo
até
o topo aqui de
onde começamos. Sim. Agora é o que ele fez
foi criar um usuário e deu a ele todas as
permissões para fazer exatamente o que ele precisa fazer, para criar todos os
recursos que ele precisa criar para que
o aplicativo funcione. Agora, todas as coisas
que tinham que fazer isso corretamente até chegar à parte do
KSQL onde ele caiu. Eu o criei para que ele
devesse falhar aqui. Agora vamos ver na
próxima seção o que
devemos fazer para que
isso funcione corretamente.
19. Project2 PacMan: como configurar os pré-requisitos: Antes de começarmos este projeto, gostaria de dar um grande
grito para Ricardo Ferrara para o aplicativo original de
streaming de jogos Pac-Man. É o aplicativo dele que estamos
realmente executando e usando hoje que eu o
ajustei e
modifiquei um pouco para
que tenhamos que
executar determinadas tarefas em nosso Confluence Cloud em para que a coisa
toda funcione. Agora que deixamos
isso de lado, é hora de ver
o que realmente
precisamos para fazer o
projeto funcionar hoje. A primeira coisa que
vamos precisar é uma conta confluente do Cloud. Se você não tiver uma conta
confluente do Cloud, eu recomendo que
você obtenha
uma, uma conta de avaliação que
deve lhe dar cerca de US $400, que é mais do que suficiente para fazer todo esse projeto funcionar. A segunda coisa que você
vai precisar é uma conta da Amazon AWS. Novamente, você pode
configurar uma conta de avaliação, que pelo curto período ela lhe dá é
mais do que suficiente. E é muito para o projeto que
vamos fazer hoje. Quando terminarmos
o projeto, você verá um bucket do S3
aqui criado para você. E então criaremos outro bucket do S3
para nossa sincronização de dados. A última coisa que você vai
precisar é Terraform. Terraform é o que vai criar o
aplicativo para nós. N vai provisionar os
recursos que precisamos em nosso AWS S3 para configurar
nosso formulário em seu Linux, basta
executar
esses três comandos. Se você ainda não o fez, eu recomendo que você vá em frente e instale o terraform em
seu sistema local. Além disso, só
precisamos de mais duas coisas. Precisamos verificar
se temos Java, então executamos o comando java
dash version. Precisamos do Java 11 ou
superior para este projeto. Portanto, certifique-se de que sua versão do
JDK seja 11 ou superior. A segunda coisa que
precisamos é o continente, para que possamos verificar
nossa versão Maven. E sim, estávamos executando o
Apache Maven 3.6.3. Se você estiver acompanhando este
tutorial até este ponto, você deve ter confluente
e ver o Cloud instalado. Você acabou de executar see cloud. Lá vamos nós. Se olharmos para
confluentes, lá vamos nós. Então, se você ainda não fez
login no seu C Cloud, eu recomendaria
que você faça isso agora, você verá
login na nuvem, traço, traço seguro. E o que isso faz é salvar suas credenciais e
o arquivo RC net. Depois de ver o Login na nuvem, ele solicitará que você coloque
suas credenciais ou, se você já tiver suas credenciais
salvas no arquivo RC net, ele apenas fará login. Agora que temos nosso
ambiente completamente configurado, vamos prosseguir e começar a
fazer nosso projeto.
20. Project2 PacMan: como configurar KSQLDB: Ok, então agora que
executamos nosso roteiro, na
verdade não é feito
tudo o que deveria fazer. Deixou um pouco
do trabalho para nós e vamos seguir em frente
e fazer esses pequenos pedaços de trabalho que
deveríamos fazer e
seguir em frente e fazer a
coisa realmente funcionar. Então, o pouco que temos que fazer agora, podemos fazer a partir do
conflito Cloud GUI. Então, entramos no novo
ambiente que Ele foi criado para nós. Entramos no cluster. E de dentro do cluster,
devemos ver um aplicativo de banco de dados
igual de caso já
configurado e criado para nós. Se entrarmos nesse
caso é igual ao aplicativo de banco de dados, mostre-nos que não temos nenhum fluxo no
momento, apenas um padrão. Não há fluxo real, apenas este fluxo padrão
que você recebe com todos os casos,
aplicativos de banco de dados iguais e sem tabelas. Além disso, se
entrarmos em tópicos, veremos que não temos tópicos, apenas este processando
logs que obtemos. Só vou
adicionar um tópico aqui. Vou chamá-lo de jogo sublinhado
do usuário. Só vou criar
isso com o padrão. Agora volto aos tópicos
e crio outro tópico chamado perdas de sublinhado do usuário. Agora que fiz isso, agora
tenho dois tópicos. Os dois tópicos que eu
disse que ia
ter no início na
visão geral deste projeto. Agora que temos
esses dois tópicos, é hora de fazer fluxos e tabelas para correlacionar
esses tópicos. Então, vou voltar
ao caso igual a dB. Neste pequeno editor aqui. Vou executar alguns comandos SQL
case. Quais esses comandos
estão disponíveis aqui nas
instruções que eu vou arquivo SQL. Você pode
abrir isso e você terá essas cinco linhas aqui
que criam dois fluxos, jogos de
usuário, perdas de usuários
e três mesas. Perdas por usuário, estatísticas por
usuário e estatísticas de resumo. Assim, podemos simplesmente copiar tudo isso, voltar ao caso igual a db e colar
aqui e executar a consulta. Lá vamos nós. Ele
executa a consulta e criou os fluxos
e as tabelas para nós. Então,
se voltarmos à nossa guia de fluxo, veremos lá vamos
que temos esse fluxo de
perdas de usuário que cria
uma tabela de perdas por usuário, depois o fluxo do jogo do usuário, que cria as estatísticas da
tabela por usuário e também alimenta uma tabela
de estatísticas resumidas. Estatísticas resumidas são apenas a tabela
extra que nos mostra a visão geral
do que está
acontecendo no jogo de cada vez. E se formos a fluxos
novamente, veremos os dois fluxos e
iremos para as mesas. Veremos essas três tabelas. Agora que fizemos
isso, na verdade é hora de
dar permissão à nossa conta de serviço para realmente
manipular os tópicos, como for necessário. Então, para isso, vamos
voltar ao nosso terminal Ubuntu. E vamos
entrar em nosso ambiente
primeiro para ver a lista de
ambientes em nuvem. Whoops, consulte a lista de
ambientes em nuvem. Em seguida, veremos o ambiente de
nuvem
usar E e Z, D N23. Então vamos
executar ver a lista de
clusters de cátodo da nuvem e ver cluster
Kafka usar
L Casey dash seis, j m r cubo, seis cubo GMR. Agora que estamos aqui, temos que executar um comando
que é C Cloud, Kafka, ACL create
dash, dash. Permitir. Em seguida, precisamos de uma conta de serviço. Bem, precisamos fazer antes
disso é que precisamos executar ver lista de contas de serviço em
nuvem, que temos cinco anos
duplo 495 na Eigenanalysis ver nuvem Kafka,
ACO, criar traço, traço, traço, traço conta de serviço 50,
duplo 4952, operação. Leia, bem como operação direita e
traço, operação de traço. Descreva traço, tópico traço, jogo sublinhado
do usuário. E é feito exatamente isso para nós. Agora, se o executarmos para perdas de sublinhado de um
usuário, isso é feito por nós. Então, agora que fizemos
tudo o que tínhamos fazer no caso igual ao lado db, podemos simplesmente executar o aplicativo novamente e começar o jogo.
21. PacMan: Execute dados de projeto e dissipador: Agora vamos começar o jogo executando o script de
início novamente, para que possamos fazer a estrela de barra para frente. Só
começará a usar o terraform para criar todo o projeto. Depois que o Terraform for inicializado
com sucesso, ele irá em frente
e criará o projeto. Novamente, esse é um processo
que leva tempo. Então, vou pausar o
vídeo aqui e voltar. Quando estiver pronto. Lá vamos nós. Então, o script de inicialização
terminou de
ser executado e acaba dando apenas essa saída com um URL que
diz que seu jogo Pac-Man
está nesse URL aqui. Abrimos isso em
uma nova guia aqui. Antes disso, não vimos nenhum bucket em nosso
S3 antes disso. E como eu disse,
estaríamos vendo um no
momento em que isso acabasse. Então, se atualizarmos
isso, lá vamos nós. Temos um bucket aqui chamado streaming,
Pac-Man e GPB. E isso foi criado para
nós pelo aplicativo. E isso contém basicamente o site Pac-Man de
streaming. Então você pode ver todos os arquivos
do site aqui. Só vou voltar para o Amazon S3 e ir para o jogo. Então, vou colocar
o nome para que possamos
chamar essa curva de habilidade de nome. E podemos jogar.
Quando fazemos isso. Vai
nos levar para a panturrilha, o jogo Pac-Man que estamos usando para o
nosso streaming de eventos, vou
gerá-lo, mas se uma pontuação, e então
vou morrer para que nós pode ver todos os
eventos possíveis e podemos ver exatamente o que isso
se parece em nosso painel de eventos. Lá vamos nós. Esse é o nosso placar. E como você pode ver,
essa pontuação é
realmente muito grande. E você acabou de me ver
lançar o aplicativo. Bem, isso porque eu
pausei o vídeo e fui em frente e
joguei o jogo um pouco para gerar um pouco mais de
pontuação e realmente tenho alguma forma ou fluxo de
muitas mensagens para
que possamos ir em frente e
veja como armazenaríamos isso usando o Kafka
Connect em nosso S3. Então, se chegarmos ao nosso S3 agora, você pode ver, é claro, que
temos nosso bucket aqui. Mas se voltarmos
ao nosso cluster Kafka, aqui, você
verá a integração de dados e verá uma seção
aqui chamada conectores. O que você pode fazer aqui
é configurar um conector para qualquer
sincronização de dados ou qualquer tipo de
lugar do qual você queira
obter informações se quiser
trazer dados para o cluster católico. Mas no nosso caso,
vamos
enviá-lo para uma pia. Então, vamos usar este aqui chamado Amazon S3 sync. Quando fizermos
isso, vai dizer, ok, o que você
realmente quer armazenar? Bem, eu só vou
dar todos os meus tópicos. Então, o primeiro,
aquele que ele nos
deu por padrão, não
queremos esse. Além disso,
queremos todos eles. Então, vamos
continuar aqui. E agora vai ficar bem, então como você deseja acessar
seu conector de sincronização S3? Eles talvez você queira usar uma chave de API existente que
você tenha para esse cluster, ou talvez você queira
escolher um acesso diferente? Mas no nosso caso, o que vamos fazer é
apenas
criar nossas credenciais de API aqui. Quando você fizer isso, ele
vai baixar o arquivo para você assim. E ele vai configurá-lo. Então, será padrão colocando você não
precisa fazer nada e você pode simplesmente
chamar isso de qualquer coisa. Você pode simplesmente chamar este coletor de traço
Pac-Man Nash S3. Então podemos continuar.
Agora aqui, na verdade é aqui que ele é
importante que você precisa de sua chave de acesso da Amazon, ID, chave de acesso secreta e seus nomes de bucket do Amazon S3. Então, o que vou fazer é
ir para o meu S3. Agora preste atenção à região. Ele diz US West para fazer meu outro bucket S3
em uma região diferente. Provavelmente vai me
dar um erro. É uma boa prática
manter todos os seus elementos de um projeto
na mesma região. Então, o que vou fazer agora é
que vou criar um balde. Vou chamar esse
balde de minha pia de traço Pac-Man. Vai ser no Oeste dos EUA dois. Não preciso mudar mais
nada aqui. Eu posso simplesmente criar o balde. Depois que ele cria o bucket. Lá vamos nós. Então você tem minha pia Pac-Man. Está tudo lá. Está tudo pronto para ir. Vou copiar
esse nome na minha pia do
Pac-Man e
trazê-lo para aqui. O ID da chave de acesso da
Amazon e a chave de
acesso secreta
da Amazon são os mesmos que você usa para a
configuração desse arquivo. Então, se você entrar na sua
configuração e puder escolher sua
chave de acesso e segredo da Amazon desse arquivo, mesmo para que eu possa
simplesmente copiar isso, colar aqui, copiar meu segredo
e colá-lo lá. E então eu posso continuar. Agora ele vai perguntar,
como você quer que seus
dados comentem? Você quer que ele
venha talvez como Avro, como proto buff quanto JSON. Então, vou fazer
um JSON porque essa é a maneira mais fácil e
também é bem definida. Portanto, é muito fácil
ver o que está dentro do seu arquivo e formato de
mensagem de saída, também JSON. Agora, quando você tiver feito essas duas coisas
vai perguntar,
ok, com que regularidade você
quer que seu S3 seja preenchido? Você quer que seja feito
por hora ou quer que seja feito todos os dias? Para este exemplo,
vou fazer isso por hora porque não vamos configurá-lo por muito tempo. Só vamos
configurá-lo por alguns minutos. Vamos ver como
os dados entram, e então esse
será o fim disso. Você não precisa entrar em configurações
avançadas. Então, se você quisesse, você
poderia alterar muitas propriedades, cujas descrições
estão aqui. Se você passar o mouse sobre o pequeno eu, ele lhe dirá
exatamente o que é isso. Eu não mexeria muito com
isso, a menos que eu tivesse
requisitos de configuração específicos para o meu projeto. Mas, por enquanto, como não o
fazemos, vamos
ignorá-lo e seguir em frente. Agora, quando você está nesta fase, ele ia perguntar
em termos de dimensionamento, quantas tarefas você
quer uma tarefa por hora? E quanto mais tarefas você
definiria para fazer por hora, peço que você atualize se for
mais de uma e até mesmo para cada tarefa cobrará 0,034 por hora no meu caso. Então, o que
vamos fazer é que vamos definir
este e
vamos continuar. Agora. Finalmente, ele só lhe
dará toda essa informação. Vai dizer, Olha, isso
é o que você pediu de nós. Tem certeza de que pode definir
o nome do conector, não o alterará aqui. Não veja o ponto para isso. E vamos
lançar e apenas ter em mente que o preço do seu conector
para cada uma das suas tarefas, sua cobrança por hora, mas também pelo seu uso ou cobrar tanto por hora, o que se soma quando
você o
inicia, você pode ver exatamente
quanto será cobrado para
ter em mente, mesmo que seja
uma conta de teste, não importa por enquanto. Mas se você estiver realmente
usando confluente e está
usando seu próprio dinheiro. Isso pode se acumular
muito rapidamente. Agora nosso conector está
sendo provisionado e, claro, o
processo leva tempo. Então, o que vou fazer é
voltar para este cluster e ir
para o conector. E vou pausar o vídeo
aqui e trazê-lo de volta. Quando tudo isso for feito. Lá vamos nós. Então, agora
nosso conector está ativo. Está em execução. Uma pequena
mensagem aqui que diz que o conector de sincronização
0 do S3 agora está em execução. Ele tem esse status em execução. E se entrarmos aqui,
sim, diz correr. Se você tiver algum problema na configuração deste conector, verá esse erro
nessa área onde ele
diria que Olhe, nós encontramos isso
neste problema. Então, você sabe, descubra. Agora vamos ver que
temos essa configuração de conector, mas o que ele realmente
enviou para a arte como três sumidouros. Então, se entrarmos em nossa sincronização S3, no momento, não tem nada. Em alguns minutos, na verdade,
enviará algo. Ela tem essa tarefa em execução. E até agora não
disse muito de nada. Então, se eu jogar
o jogo um pouco mais, jogar um pouco o jogo,
pausar o vídeo, voltar e veremos
o que ele realmente é enviado
para o nosso cluster S3. Quero dizer, sincronização de dados do S3. Ok, então eu joguei o jogo um
pouco em uma conta diferente. Se formos para o
placar, vamos dizer isso. Sim, tem uma segunda conta, tem uma pontuação de 1000
na antiga. Mas se voltarmos
ao nosso bucket do S3 agora, que está aqui, agora veremos que ele tem esse tópico de
pastas dentro. E se entrarmos, ele tem pastas para cada coisa para a qual
recebeu informações. Se entrarmos no jogo do usuário. E tem o ano, o mês, o
dia e a hora. E nesta hora ele
recebeu esses JSON. Vamos ver, vamos abrir
um desses JSON e ver o que ele
realmente tem dentro dele. Se abrirmos isso. No meu caso,
provavelmente será
baixado ainda e
podemos abrir isso. Podemos ver que ela compartilhou todas essas informações
conosco neste JSON, que havia esse usuário
jogando o jogo e ele gerou tanta pontuação. É assim que podemos usar
uma sincronização de dados para armazenar todas as informações consumidas em nosso cluster Kafka. Mas tudo é salvo. E se precisarmos
consultá-lo ou verificá-lo mais tarde, tudo está disponível para nós
aqui em nossa sincronização de dados. Agora que fizemos isso, sabemos como sincronizar trabalhos
e vimos isso em execução. Isso está realmente ocupando
muitos recursos para ser executado. O que vou fazer agora
vou mostrar como você pode destruir todos esses recursos
que você criou. A primeira coisa que você
quer fazer é você querer
entrar no seu conector
e apenas dizer:
Olha, eu não quero mais esse
conector funcionando. Então excluído. Você copia esse nome para
o nome do conector. E lá vai você. Confirme. Seu conector
de sincronização S3 foi excluído, desaparecido. Você não tem mais esse conector
disponível para você. Então, se você voltar para
o Ubuntu aqui, você só precisa executar o script. Então você diria “dot
slash”, stop, dot SH. E está dizendo
agora que vai
destruir todos os recursos
que o fizeram dizer? Sim. Certo, vá em frente e faça isso. E agora ele vai continuar destruindo todos os
recursos criados. Este é um processo que leva
tempo para ser executado também. Então, vou
pausar o vídeo aqui e voltar
quando tudo estiver pronto. Lá vamos nós. Agora, ele executou com sucesso
o script de parada e
destruiu todos os
recursos alocados para
criar este projeto. Se você for ao nosso S3, agora,
se formos para nossos coletores S3, descobriremos
que esse bucket S3 que
criamos para nosso projeto, ele desapareceu e podemos excluir esse bucket apenas
esvaziando-o. Então, podemos apenas dizer que olhe exclua
permanentemente. Então você pode preencher isso,
preenchido com exclusão permanente. Depois de fazer isso, você pode sair desse intervalo e
excluir esse intervalo. Para isso, você só
precisa copiar a pasta, copiar o nome e
colá-lo aqui. Sim, isso está feito. E se você for até a nuvem do
console, você vai para os ambientes. Você descobrirá que o
ambiente desapareceu completamente. Com isso, você executou
com sucesso o projeto dois, você
o completou e bem feito.