< Return to Video

PSCC CAP02 2025 VA04 AWS INGESTAO DE DADOS COM GLUE

  • 0:08 - 0:12
    Na AWS a gente consegue
    capturar dados desde a entrada
  • 0:12 - 0:15
    e já fazer a consulta nesses dados,
  • 0:15 - 0:17
    sem ter que configurar
    praticamente nada,
  • 0:17 - 0:19
    usando o serviço do Glue.
  • 0:19 - 0:20
    Então primeiro vamos mostrar
    para vocês
  • 0:20 - 0:25
    como que a gente faz a partir
    de um dado como o arquivo CSV,
  • 0:25 - 0:29
    incluir esse dado na AWS e depois
    fazer uma consulta SQL nesse dado
  • 0:29 - 0:31
    que a gente acabou de inserir.
  • 0:31 - 0:36
    Aqui no console,
    eu vou acessar aqui o serviço do "S3",
  • 0:36 - 0:39
    que é o serviço de armazenamento
    de objetos da AWS.
  • 0:42 - 0:45
    E vou criar o bucket de entrada,
  • 0:45 - 0:49
    é um repositório onde eu coloco
    diversos tipos de arquivos.
  • 0:49 - 0:51
    Pode ser imagem,
    pode ser um texto,
  • 0:51 - 0:53
    pode ser um arquivo CSV,
    por exemplo.
  • 0:53 - 0:57
    Então,
    vou criar aqui o meu bucket.
  • 0:57 - 1:00
    Vou criar aqui
    "ftf-bucket-dados-brutos",
  • 1:00 - 1:03
    que é onde a gente vai fazer
    a carga do nosso arquivo CSV.
  • 1:03 - 1:07
    O bucket "propósito geral" mesmo.
  • 1:07 - 1:08
    Aqui eu não marco nada.
  • 1:08 - 1:11
    Não preciso ter acesso público.
  • 1:11 - 1:14
    Ou melhor, vou manter bloqueado aqui
    o "acesso público".
  • 1:14 - 1:17
    Só acesso pela AWS mesmo.
  • 1:17 - 1:22
    Não preciso de "versionamento"
    e não preciso da "chave do bucket".
  • 1:22 - 1:24
    Vou criar aqui o nosso bucket.
  • 1:28 - 1:30
    Então a gente já criou
    o nosso bucket de entrada,
  • 1:30 - 1:32
    que é onde a gente vai gravar
    um arquivo CSV.
  • 1:32 - 1:35
    Então vamos gravar aqui
    um arquivo CSV
  • 1:35 - 1:39
    e depois criar um bucket
    onde ele vai executar consultas SQL
  • 1:39 - 1:42
    e depois cada consulta gera
    um arquivo separadamente
  • 1:42 - 1:45
    e eu consigo ter a extração
    das informações que eu preciso.
  • 1:45 - 1:47
    Então,
    vou clicar aqui
  • 1:47 - 1:53
    no nosso "ftf-bucket-dados-brutos"
    e vou subir um arquivo CSV.
  • 1:53 - 1:56
    Vou fazer uma carga desse arquivo.
  • 1:56 - 1:58
    Vou clicar em "adicionar arquivos".
  • 1:58 - 1:59
    Então, eu já tinha baixado aqui
    o arquivo,
  • 1:59 - 2:04
    vou clicar aqui em "downloads",
    "employees.csv",
  • 2:04 - 2:07
    dou um "open"
    e vou fazer a carga.
  • 2:07 - 2:10
    É um arquivo simples,
    ele tem um pouco mais de 1 mega,
  • 2:10 - 2:13
    dois mega quase.
  • 2:13 - 2:18
    Já está lá disponível para a gente
    e já vou deixar um bucket pré-criado
  • 2:18 - 2:22
    para quando a gente for fazer
    consultas nesses dados,
  • 2:22 - 2:26
    ele salvar os resultados
    nesse bucket de saída, tá?
  • 2:26 - 2:30
    Vou criar aqui o bucket,
    que eu vou chamar...
  • 2:30 - 2:34
    A gente precisa lembrar
    que o nome do bucket
  • 2:34 - 2:35
    tem que ser único no mundo.
  • 2:35 - 2:39
    Então, sempre tenta colocar
    algo que seja identificador único seu.
  • 2:39 - 2:42
    Por exemplo, as suas iniciais,
    que é o que a gente vai usar.
  • 2:42 - 2:46
    Vou colocar aqui
    "ftf-bucket-",
  • 2:46 - 2:49
    ftf são as minhas iniciais,
  • 2:49 - 2:54
    "bucket-saida-glue".
  • 2:54 - 2:56
    que é o que a gente vai executar,
    ou melhor,
  • 2:56 - 2:58
    a gente vai executar aqui o "athen".
  • 3:02 - 3:07
    Vou deixar essa parte pré-configurada
    "sem versionamento" também,
  • 3:07 - 3:08
    sem "chave do bucket".
  • 3:14 - 3:18
    Então, eu tenho o meu bucket
    de arquivos de entrada
  • 3:18 - 3:20
    e depois quando eu executar
    a consulta SQL
  • 3:20 - 3:23
    eu tenho um bucket
    que vai armazenar as consultas.
  • 3:23 - 3:26
    Agora a gente vai fazer
    o segundo passo,
  • 3:26 - 3:31
    que é criar um crawler,
    que é um serviço
  • 3:31 - 3:35
    que vai buscar dados
    dentro desse bucket de entrada.
  • 3:35 - 3:37
    Então, toda vez que a gente
    tiver um arquivo novo,
  • 3:37 - 3:39
    ele automaticamente vai identificar
  • 3:39 - 3:43
    quais são as características
    desse arquivo, ou seja,
  • 3:43 - 3:45
    o tamanho do arquivo,
  • 3:45 - 3:48
    as colunas que eu vou utilizar,
    ele vai inferir isso
  • 3:48 - 3:51
    para que eu consiga fazer
    consultas nesse arquivo.
  • 3:51 - 3:54
    Vou colocar aqui no serviço,
    na caixa de busca.
  • 3:54 - 3:59
    Vou colocar aqui "glue",
    "AWS Glue" está aqui.
  • 4:06 - 4:10
    Esse é o serviço do "AWS Glue",
    a gente tem aqui os "Jobs ETL",
  • 4:10 - 4:14
    e mais para baixo,
    a gente tem algumas configurações.
  • 4:14 - 4:18
    Vou clicar aqui em "ETL Jobs".
  • 4:18 - 4:20
    Então,
    aqui a gente tem várias configurações
  • 4:20 - 4:24
    dentro desse ambiente do Glue,
    posso rodar o serviço de ETL
  • 4:24 - 4:26
    que é extração,
    transformação e carga.
  • 4:26 - 4:29
    Ou eu vou rodar,
    como se fosse um robô
  • 4:29 - 4:30
    que é chamado de crawler,
  • 4:30 - 4:34
    que vai tentar buscar
    em algum caminho específico,
  • 4:34 - 4:37
    seja lá um bucket,
    como a gente criou.
  • 4:37 - 4:39
    Vai identificar as características
    dos arquivos
  • 4:39 - 4:42
    para que a gente consiga
    extrair os metadados
  • 4:42 - 4:46
    e a gente faça consultas
    SQL dentro desses metadados.
  • 4:46 - 4:50
    Então,
    vou criar aqui um crawler.
  • 4:50 - 5:00
    Vou chamar aqui
    de "crawler-dados-brutos".
  • 5:00 - 5:03
    Vou clicar em avançar.
  • 5:03 - 5:05
    Eu vou adicionar aqui
    um "data source".
  • 5:05 - 5:08
    De onde vem a fonte
    desses dados?
  • 5:08 - 5:09
    "Adicionar um data source".
  • 5:09 - 5:12
    Ele vem lá do bucket do "s3".
  • 5:12 - 5:16
    Aqui embaixo eu vou buscar
    aonde está esse bucket do "s3".
  • 5:16 - 5:18
    Está nessa conta.
  • 5:18 - 5:20
    Vou clicar aqui "browse s3"
  • 5:20 - 5:24
    para fazer a busca
    desse bucket do "s3".
  • 5:24 - 5:29
    É o nosso banco de dados de entrada,
    nossos dados brutos.
  • 5:29 - 5:31
    Vou clicar em "choose".
  • 5:31 - 5:33
    Aqui por enquanto está vermelho,
    se eu clicar fora,
  • 5:33 - 5:35
    some a mensagem.
  • 5:35 - 5:39
    Tem as configurações
    que ele pode buscar por subpastas,
  • 5:39 - 5:42
    que é o que a gente deixou
    pré-selecionado
  • 5:42 - 5:44
    ou só para novas pastas.
  • 5:44 - 5:46
    O que isso quer dizer?
  • 5:46 - 5:51
    Você pode preparar esse crawler
    para buscar
  • 5:51 - 5:54
    sempre que tiver um arquivo novo
    dentro desse bucket,
  • 5:54 - 5:56
    ou só quando eu subir
    uma pasta nova,
  • 5:56 - 5:59
    porque ele já sabe que aquilo
    é algo novo
  • 5:59 - 6:03
    e não precisa procurar
    em todos os arquivos dentro da AWS.
  • 6:03 - 6:07
    Então aqui a gente vai deixar
    para marcar a primeira opção mesmo
  • 6:07 - 6:13
    dentro do "sub-folders"
    e vou adicionar essa fonte de dados.
  • 6:13 - 6:16
    Vou clicar em "next".
  • 6:16 - 6:21
    Aqui eu preciso selecionar
    a nossa função de teste,
  • 6:21 - 6:24
    nosso ambiente de teste,
    que é o "LabRole",
  • 6:24 - 6:28
    com essa função a gente consegue
    executar as consultas necessárias.
  • 6:28 - 6:30
    Vou dar um "next".
  • 6:33 - 6:36
    Eu vou configurar agora
    uma base de dados
  • 6:36 - 6:40
    para que quando o meu arquivo
    do meu bucket,
  • 6:40 - 6:41
    ele vai criar uma base de dados
    metadados.
  • 6:41 - 6:42
    O que são os metadados?
  • 6:42 - 6:46
    Ele vai dar informações
    dos tipos de colunas,
  • 6:46 - 6:47
    de como é a estrutura
    desses dados
  • 6:47 - 6:50
    que estamos fazendo essa leitura.
  • 6:50 - 6:51
    Então vou clicar aqui,
  • 6:51 - 6:54
    "add database".
  • 6:54 - 6:55
    Ele vai abrir aqui uma nova janela.
  • 6:55 - 6:59
    Ele está aqui nessa guia de database,
  • 6:59 - 7:01
    se eu clicasse aqui,
    por exemplo,
  • 7:01 - 7:04
    posso criar uma nova base de dados,
  • 7:04 - 7:06
    que é a mesma tela que a gente caiu.
  • 7:06 - 7:12
    Vou colocar aqui o nome
    "db-metadados".
  • 7:15 - 7:19
    E vou clicar em "criar database".
  • 7:19 - 7:24
    Já tenho a base de dados
    criada aqui para a gente.
  • 7:24 - 7:27
    Agora eu vou voltar
    para a parte da criação do crawler
  • 7:27 - 7:29
    para que a gente aponte
    para essa nova base de dados
  • 7:29 - 7:31
    que a gente acabou de criar.
  • 7:31 - 7:35
    Voltei aqui para nossa tela,
    estava em outra aba,
  • 7:35 - 7:37
    a gente estava aqui
    na parte de criação.
  • 7:37 - 7:41
    Voltei para a aba anterior.
    Vou dar um refresh.
  • 7:41 - 7:45
    Já está aqui a nossa
    base de dados de metadados, tá?
  • 7:45 - 7:49
    Posso colocar opcionalmente
    um prefixo para o nome das tabelas
  • 7:49 - 7:50
    que ele vai criar ou não.
  • 7:50 - 7:52
    Vou deixar assim por enquanto.
  • 7:52 - 7:54
    E essa informação de baixo
    é importante.
  • 7:54 - 7:58
    Ele define quando a gente
    vai executar esse crawler,
  • 7:58 - 8:02
    esse robô que vai de tempos
    em tempos buscar informações novas
  • 8:02 - 8:04
    no nosso bucket.
  • 8:04 - 8:07
    A gente tem as opções sob demanda,
  • 8:07 - 8:10
    a cada hora, diariamente,
    semanalmente, mensalmente,
  • 8:10 - 8:14
    ou você define quando que você quer
    exatamente executar.
  • 8:14 - 8:16
    Então,
    a gente vai executar sob demanda.
  • 8:16 - 8:18
    Então, a gente vai ativar
    somente quando a gente precisar
  • 8:18 - 8:21
    que ele leia arquivos novos.
  • 8:21 - 8:28
    Vou clicar aqui em "next"
    e vou criar aqui o nosso crawler.
  • 8:28 - 8:31
    Ele está criando aqui o crawler,
    vou dar um refresh.
  • 8:34 - 8:38
    Vamos aguardar
    mais alguns instantes.
  • 8:38 - 8:40
    Vou clicar aqui novamente
    em "crawlers".
  • 8:44 - 8:45
    Pronto.
  • 8:45 - 8:49
    Já apareceu aqui o nosso crawler,
    ele está pronto para ser executado.
  • 8:49 - 8:52
    Ele ainda não foi nenhuma vez
    executado.
  • 8:52 - 8:53
    Está aqui,
    não tem um agendamento,
  • 8:53 - 8:56
    ele é sob demanda mesmo, tá?
  • 8:56 - 8:58
    E aí eu posso mandar executar,
    vou dar aqui um "run".
  • 9:06 - 9:07
    O que ele está fazendo agora?
  • 9:07 - 9:10
    Ele está indo no bucket do "s3"
    que a gente criou,
  • 9:10 - 9:13
    vai procurar por todos arquivos
    que tem ali dentro
  • 9:13 - 9:15
    e para cada arquivo que ele encontrar,
  • 9:15 - 9:18
    ele vai entender a estrutura dele,
    vai tentar inferir o tipo de dado
  • 9:18 - 9:21
    que está em cada coluna
    do nosso arquivo CSV,
  • 9:21 - 9:25
    para que a gente depois consiga
    fazer uma consulta usando SQL,
  • 9:25 - 9:29
    por exemplo,
    dentro desse bucket que a gente criou.
  • 9:29 - 9:31
    Então aqui ele já executou
    o nosso crawler,
  • 9:31 - 9:34
    executou aqui com sucesso.
  • 9:34 - 9:35
    Então,
    a gente vai ver aqui.
  • 9:35 - 9:39
    Vou dar um refresh para ele
    atualizar aqui as informações.
  • 9:39 - 9:41
    Posso clicar aqui no nosso crawler.
  • 9:43 - 9:47
    Já mostra quando foi
    a última vez que ele foi executado.
  • 9:47 - 9:49
    Vou clicar aqui
    na nossa base de dados
  • 9:49 - 9:52
    para ver se ele criou alguma tabela
    daquilo que ele achou.
  • 9:52 - 9:55
    Vou clicar aqui em "tables".
  • 9:55 - 9:56
    O que ele criou aqui?
  • 9:56 - 10:01
    "ftf_bucket_dados_brutos".
  • 10:01 - 10:05
    Ele tinha lá um arquivo
    e aqui a gente vai ver
  • 10:05 - 10:09
    o que ele identificou de dados
    nesse arquivo que a gente subiu.
  • 10:09 - 10:12
    Então,
    a gente já executou o nosso crawler.
  • 10:12 - 10:14
    Aqui nas tabelas
    ele vai dar as informações
  • 10:14 - 10:17
    daquilo que ele conseguiu visualizar.
  • 10:17 - 10:20
    Eu posso ver os dados diretamente,
    eu posso ver os metadados.
  • 10:20 - 10:24
    Vou clicar aqui para ver
    as características desses dados.
  • 10:24 - 10:26
    "View Data Quality".
  • 10:26 - 10:28
    E aqui em "table overview",
  • 10:28 - 10:30
    ele vai me dar o que ele entendeu
    desses dados.
  • 10:30 - 10:35
    Ele já identificou, por exemplo,
    14 colunas.
  • 10:35 - 10:38
    Tem o ID do funcionário,
    por exemplo,
  • 10:38 - 10:40
    vai ter aquele tipo de dado
    que ele identificou.
  • 10:40 - 10:45
    Ele identificou como "bigint",
    cidade como "string",
  • 10:45 - 10:47
    o índice de desenvolvimento da cidade
    como "double"
  • 10:47 - 10:48
    e assim por diante.
  • 10:48 - 10:49
    Então, legal.
  • 10:49 - 10:51
    Isso aqui são os metadados
    que ele identificou para depois
  • 10:51 - 10:55
    eu consiga fazer uma consulta
    eu já sei com que tipo de dado
  • 10:55 - 10:57
    que eu estou lidando.
  • 10:57 - 11:01
    Então, vou voltar aqui novamente
    para as minhas tabelas,
  • 11:01 - 11:06
    vou selecionar aqui a nossa tabela
    e vou clicar em "table data".
  • 11:06 - 11:08
    Assim que eu clicar em "table data"
  • 11:08 - 11:11
    ele vai abrir um novo serviço
    chamado Athena,
  • 11:11 - 11:14
    que é um serviço
    que permite rodar consulta SQL
  • 11:14 - 11:18
    nesse conjunto de dados
    que a gente acabou de mapear,
  • 11:18 - 11:21
    de definir os metadados
    e fazer uma consulta
  • 11:21 - 11:24
    e extrair informações agregadas,
    por exemplo.
  • 11:24 - 11:26
    Vou voltar aqui para a gente ver.
  • 11:26 - 11:30
    Vou clicar aqui em "table data".
  • 11:30 - 11:32
    Vai abrir aqui
    uma nova guia para a gente.
  • 11:36 - 11:38
    E veja que ele já criou aqui
    uma query SQL.
  • 11:38 - 11:41
    Só que antes de executar essa query,
    ele está falando:
  • 11:41 - 11:44
    "você não definiu
    o local de saída dessa query."
  • 11:44 - 11:48
    Eu preciso definir isso
    antes de configurar,
  • 11:48 - 11:51
    executar essa consulta SQL.
  • 11:51 - 11:58
    Vou clicar aqui em configurações
    e vou clicar em "gerenciar".
  • 11:58 - 12:03
    Aqui tem a opção de colocar
    onde vai ter o resultado
  • 12:03 - 12:07
    das queries que eu fizer pela Athena,
    a gente vai colocar aqui.
  • 12:07 - 12:10
    Vamos clicar em "Browse s3"
  • 12:10 - 12:13
    e vamos escolher o nosso
    bucket de saída que a gente criou
  • 12:13 - 12:15
    logo no começo dessa matéria.
  • 12:18 - 12:20
    Vou clicar aqui em "escolher".
  • 12:25 - 12:30
    E vou clicar em salvar.
  • 12:30 - 12:31
    Legal.
  • 12:31 - 12:35
    Vou voltar aqui para o nosso editor.
  • 12:35 - 12:38
    Já sumiu aquela
    mensagem de erro.
  • 12:38 - 12:41
    Eu consigo visualizar
    as tabelas que ele criou,
  • 12:41 - 12:45
    a tabela ele deu o mesmo nome
    do bucket que a gente já tinha
  • 12:45 - 12:48
    e aqui tem umas colunas
    que ele identificou.
  • 12:48 - 12:54
    Então, vou fazer uma consulta
    nesse catálogo de metadados,
  • 12:54 - 12:57
    nessa base de dados,
    nessa tabela aqui.
  • 12:57 - 12:59
    Eu poderia até renomear
    essa tabela,
  • 12:59 - 13:02
    mas vamos executar assim mesmo,
    só para a gente ver a consulta
  • 13:02 - 13:04
    como vem para a gente.
  • 13:04 - 13:07
    Vou clicar "executar".
  • 13:07 - 13:08
    Pronto.
  • 13:08 - 13:12
    A gente já conseguiu consultar
    todos os dados do nosso arquivo CSV.
  • 13:15 - 13:17
    Veja que a gente não precisou
    configurar o banco de dados.
  • 13:17 - 13:21
    A gente acessou diretamente
    o arquivo sem configurar nada da AWS,
  • 13:21 - 13:24
    a gente carregou um arquivo
    dentro do S3
  • 13:24 - 13:29
    e a gente rodou um robô
    chamado crawler
  • 13:29 - 13:32
    para conseguir extrair os metadados
    para que a gente conseguisse
  • 13:32 - 13:35
    executar uma consulta
    SQL dentro desses arquivos.
Title:
PSCC CAP02 2025 VA04 AWS INGESTAO DE DADOS COM GLUE
Video Language:
Portuguese, Brazilian
Duration:
13:39

Portuguese, Brazilian subtitles

Incomplete

Revisions Compare revisions