Análise de dados em tempo real com Kubernetes, Redis e BigQuery

Neste tutorial, você fará análises de dados do Twitter em tempo real com um pipeline baseado em Google Compute Engine, Kubernetes, Redis e BigQuery. Esse tipo de análise tem várias aplicações úteis, como:

  • fazer análises de sentimentos;
  • identificar tendências e padrões gerais em dados;
  • monitorar o desempenho e o alcance das campanhas;
  • elaborar respostas em tempo real.

O diagrama a seguir descreve a arquitetura do aplicativo de exemplo.

A arquitetura do exemplo de aplicativo

No aplicativo de exemplo, é usado um controlador de replicação com um pod replicado, para fins de compatibilidade com um Redis mestre que armazena em cache os tweets recebidos. O Redis mestre é encabeçado por um serviço.

Um pod replicado, definido por meio de uma implantação, lê a amostra de stream pública do Twitter com a Twitter Streaming API e despeja, no cache do Redis, os tweets que correspondem ao respectivo conjunto de filtros predefinido. Dois outros pods replicados bloqueiam as leituras no cache do Redis. Quando os dados de tweet estão disponíveis, esses pods adicionam os dados ao BigQuery em pequenos lotes usando a BigQuery API.

Objetivos

  • Fazer o download do código-fonte.
  • Configurar e iniciar um cluster do Kubernetes.
  • Criar um aplicativo do Twitter.
  • Iniciar o aplicativo Kubernetes.
  • Usar o BigQuery para consultar dados do Twitter.

Custos

Este tutorial usa vários componentes faturáveis do Google Cloud Platform, como:

  • cinco instâncias de máquina virtual n1-standard-1 do Google Compute Engine;
  • cinco discos permanentes de 10 GB do Google Compute Engine;
  • BigQuery.

O custo de executar este tutorial varia de acordo com o tempo de execução. Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Novos usuários do Cloud Platform podem ser qualificados para uma avaliação gratuita.

Antes de começar

Criar e configurar um novo projeto

Para trabalhar neste exemplo, é preciso ter um projeto com as APIs necessárias ativadas. No console do Google Cloud Platform, crie um projeto novo e ative a Google Compute Engine API. Você será solicitado a ativar o faturamento, caso não tenha feito isso anteriormente.

Este tutorial também usa as seguintes APIs que foram ativadas por padrão quando você criou o novo projeto:

  • BigQuery
  • Google Cloud Storage JSON API

Configurar o Google Cloud SDK

  1. Autentique usando sua conta do Google:

    gcloud auth login
    
  2. Defina o projeto padrão do Cloud SDK como o projeto que você selecionou na seção anterior deste tutorial. Substitua PROJECT_ID pelo seu código:

    gcloud config set project [PROJECT_ID]
    
  3. Atualize os componentes:

    gcloud components update
    
  4. Instale o binário kubectl:

    gcloud components update kubectl
    
  5. Adicione o diretório ao kubectl no caminho:

    export PATH=$PATH:/usr/local/share/google/google-cloud-sdk/bin/
    

Fazer o download do código de exemplo

Há duas maneiras de conseguir o código de exemplo:

  • Fazer o download do arquivo zip. Descompacte o código em um diretório chamado kube-redis-bq.

  • Clonar o repositório do GitHub. Em uma janela de terminal, execute o comando a seguir:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-bigquery-python.git kube-redis-bq
    

Fazer o download do Kubernetes

O Kubernetes é um sistema de articulação de código aberto para contêineres do Docker. Ele programa contêineres nas instâncias do cluster do Compute Engine, gerencia cargas de trabalho para garantir que o estado delas corresponda às intenções declaradas e organiza os contêineres por marcador e tipo de tarefa para facilitar o gerenciamento e a descoberta.

  1. Faça o download da versão mais recente do binário do Kubernetes.

  2. Descompacte o arquivo no mesmo diretório pai em que você instalou o código de exemplo. Como o arquivo .tar será descompactado em um diretório chamado kubernetes, não é preciso criar um novo diretório. Por exemplo, digite:

    tar -zxvf kubernetes.tar.gz
    

Como criar a tabela do BigQuery

Crie uma tabela do BigQuery para armazenar seus tweets. O BigQuery agrupa tabelas em camadas de abstração chamadas conjuntos de dados. Use a ferramenta de linha de comando bq, que vem incluída no Cloud SDK, para criar um novo conjunto de dados do BigQuery chamado rtda.

  1. Em uma janela de terminal, digite o seguinte comando:

    bq mk rtda
    
  2. Agora que você já definiu um conjunto de dados, crie uma nova tabela chamada tweets para os tweets recebidos. É necessário que cada tabela do BigQuery seja definida por um esquema. Para poupar tempo, este exemplo fornece um esquema predefinido, schema.json, que você pode usar para definir sua tabela. Para criar a tabela usando o esquema predefinido, digite o seguinte comando:

    bq mk -t rtda.tweets kube-redis-bq/bigquery-setup/schema.json
    
  3. Para verificar se o conjunto de dados e a tabela foram criados, use a IU da Web do BigQuery. Você verá o conjunto de dados na barra lateral esquerda. Se ele não estiver lá, verifique se está olhando no projeto certo. Quando você clicar na seta ao lado do nome do conjunto de dados, a nova tabela será exibida. Como alternativa, você pode executar os comandos a seguir para ver todos os conjuntos de dados em um projeto ou todas as tabelas em um determinado conjunto de dados:

    bq ls [PROJECT_ID]:
    
    bq ls [DATASET_ID]
    

    Neste caso, o código do conjunto de dados é rtda.

  4. Finalmente, edite kube-redis-bq/redis/bigquery-controller.yaml. Atualize o value dos seguintes campos para refletir sua configuração do BigQuery:

    • PROJECT_ID: o código do projeto.
    • BQ_DATASET: o conjunto de dados do BigQuery que contém sua tabela (rtda).
    • BQ_TABLE: a tabela do BigQuery que você acabou de criar (tweets).
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: bigquery-controller
  labels:
    name: bigquery-controller
spec:
  replicas: 2
  template:
    metadata:
      labels:
        name: bigquery-controller
    spec:
      containers:
      - name: bigquery
        image: gcr.io/google-samples/redis-bq-pipe:v5
        env:
        - name: PROCESSINGSCRIPT
          value: redis-to-bigquery
        - name: REDISLIST
          value: twitter-stream
        # Change this to your project ID.
        - name: PROJECT_ID
          value: xxxx
        # Change the following two settings to your dataset and table.
        - name: BQ_DATASET
          value: xxxx
        - name: BQ_TABLE
          value: xxxx

Como configurar e iniciar um cluster do Kubernetes

Não é necessária nenhuma instalação porque o Kubernetes é portátil, ou seja, ele usa um conjunto de scripts de shell para iniciar, encerrar e gerenciar a configuração.

  1. Edite kubernetes/cluster/gce/config-common.sh.

  2. Adicione o escopo bigquery à definição NODE_SCOPES do arquivo.

Esta configuração permite que os nós gravem na sua tabela do BigQuery. Salve a configuração e feche o arquivo.

(Opcional) Atualizar os scripts de inicialização para aumentar a confiabilidade do Redis a longo prazo

Você pode melhorar a confiabilidade do Redis a longo prazo no Kubernetes adicionando algumas otimizações sugeridas a scripts de inicialização dos nós. Esta etapa é útil se você quer que o Redis mestre funcione por um longo período de tempo. Caso não pretenda ter o cluster funcionando por muito tempo, ignore esta etapa.

  1. Edite kubernetes/cluster/gce/configure-vm.sh e role até o final do arquivo. Acima desta instrução if, após a linha de símbolos #:

    if [[ -z "${is_push}" ]]; then
    
  2. Insira os seguintes comandos:

    /sbin/sysctl vm.overcommit_memory=1
    echo never > /sys/kernel/mm/transparent_hugepage/enabled
    

Esses comandos definirão o kernel do Linux para sempre sobrecarregar a memória e desativarão grandes páginas transparentes no kernel. Salve e feche o arquivo.

Iniciar o cluster

Agora você está pronto para iniciar o cluster.

  1. Insira o seguinte comando:

    kubernetes/cluster/kube-up.sh
    

    Iniciar o cluster pode levar algum tempo. Durante o processo de inicialização, talvez você precise criar uma nova chave SSH para o Google Compute Engine ou, caso já tenha feito isso anteriormente, inserir a senha longa da chave SSH.

  2. Após a inicialização do cluster, insira os seguintes comandos para ver as instâncias em execução:

    kubectl get nodes
    kubectl cluster-info

Será exibida uma instância do Kubernetes mestre e quatro nodes do Kubernetes.

Criar um aplicativo do Twitter

Para receber tweets do Twitter, você precisa criar um aplicativo do Twitter e adicionar os respectivos valores de chave secreta/token secreto à especificação do pod Kubernetes do Twitter para o Redis. Ao todo, você copiará quatro valores. Siga estas etapas:

  1. Crie um novo aplicativo do Twitter.
  2. Na página do Twitter Gerenciamento de aplicativos, navegue até a guia Chaves e tokens de acesso.
  3. Clique no botão Criar meu token de acesso para gerar um novo token.
  4. Edite kube-redis-bq/redis/twitter-stream.yaml.
  5. Substitua os valores a seguir pela chave do cliente e pelo segredo do cliente:
    • CONSUMERKEY
    • CONSUMERSECRET
  6. Substitua os valores a seguir pelo seu token de acesso e pelo segredo do token de acesso:
    • ACCESSTOKEN
    • ACCESSTOKENSEC

Por padrão, o aplicativo de exemplo realiza a leitura com base em uma amostra aleatória da stream pública do Twitter. Para filtrar um conjunto de palavras-chave em vez disso:

  1. Edite kube-redis-bq/twitter-stream.yaml e altere o valor de TWSTREAMMODE para filter.
  2. Edite twitter-to-redis.py e substitua as palavras-chave definidas na variável track pelas palavras-chave que quer usar para filtrar.
  3. Recrie a imagem do contêiner. Para ver instruções sobre como criar a imagem do contêiner, consulte o apêndice.

Noções básicas sobre a imagem Docker para os pods Kubernetes

Este exemplo usa três modelos diferentes de pod Kubernetes para criar o pipeline de análise. Um deles é um pod Redis e os outros dois tipos executam os scripts do exemplo de aplicativo.

Os arquivos de especificação apontam para uma imagem Docker predefinida. Você não precisa fazer nada de especial para usá-la. Caso queira criar a imagem, siga as etapas do apêndice.

A imagem Docker contém dois scripts principais que realizam o trabalho para esta solução.

O código em twitter-to-redis.py transmite tweets recebidos do Twitter para o Redis.

#!/usr/bin/env python
# Copyright 2014 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""This script uses the Twitter Streaming API, via the tweepy library,
to pull in tweets and store them in a Redis server.
"""

import datetime
import os

import redis
from tweepy import OAuthHandler
from tweepy import Stream
from tweepy.streaming import StreamListener

# Get your twitter credentials from the environment variables.
# These are set in the 'twitter-stream.json' manifest file.
consumer_key = os.environ['CONSUMERKEY']
consumer_secret = os.environ['CONSUMERSECRET']
access_token = os.environ['ACCESSTOKEN']
access_token_secret = os.environ['ACCESSTOKENSEC']

# Get info on the Redis host and port from the environment variables.
# The name of this variable comes from the redis service id, 'redismaster'.
REDIS_HOST = os.environ['REDISMASTER_SERVICE_HOST']
REDIS_PORT = os.environ['REDISMASTER_SERVICE_PORT']
REDIS_LIST = os.environ['REDISLIST']

class StdOutListener(StreamListener):
    """A listener handles tweets that are received from the stream.
    This listener dumps the tweets into Redis.
    """

    count = 0
    redis_errors = 0
    allowed_redis_errors = 3
    twstring = ''
    tweets = []
    r = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0)
    total_tweets = 10000000

    def write_to_redis(self, tw):
        try:
            self.r.lpush(REDIS_LIST, tw)
        except:
            print 'Problem adding data to Redis.'
            self.redis_errors += 1

    def on_data(self, data):
        """What to do when tweet data is received."""
        self.write_to_redis(data)
        self.count += 1
        # if we've grabbed more than total_tweets tweets, exit the script.
        # If this script is being run in the context of a kubernetes
        # replicationController, the pod will be restarted fresh when
        # that happens.
        if self.count > self.total_tweets:
            return False
        if self.redis_errors > self.allowed_redis_errors:
            print 'too many redis errors.'
            return False
        if (self.count % 1000) == 0:
            print 'count is: %s at %s' % (self.count, datetime.datetime.now())
        return True

    def on_error(self, status):
        print status

if __name__ == '__main__':
    print '....'
    listener = StdOutListener()
    auth = OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_token_secret)
    print 'stream mode is: %s' % os.environ['TWSTREAMMODE']

    stream = Stream(auth, listener)
    # set up the streaming depending upon whether our mode is 'sample', which
    # will sample the twitter public stream. If not 'sample', instead track
    # the given set of keywords.
    # This environment var is set in the 'twitter-stream.yaml' file.
    if os.environ['TWSTREAMMODE'] == 'sample':
        stream.sample()
    else:
        stream.filter(
                track=['bigdata', 'kubernetes', 'bigquery', 'docker', 'google',
                       'googlecloud', 'golang', 'dataflow',
                       'containers', 'appengine', 'gcp', 'compute',
                       'scalability', 'gigaom', 'news', 'tech', 'apple',
                       'amazon', 'cluster', 'distributed', 'computing',
                       'cloud', 'android', 'mobile', 'ios', 'iphone',
                       'python', 'recode', 'techcrunch', 'timoreilly']
                )

O código em redis-to-bigquery.py transmite dados armazenados em cache do Redis para o BigQuery.

#!/usr/bin/env python
# Copyright 2014 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""This script grabs tweets from a redis server, and stores them in BiqQuery
using the BigQuery Streaming API.
"""
import datetime
import json
import os

import redis

import utils

# Get info on the Redis host and port from the environment variables.
# The name of this variable comes from the redis service id, 'redismaster'.
REDIS_HOST = os.environ['REDISMASTER_SERVICE_HOST']
REDIS_PORT = os.environ['REDISMASTER_SERVICE_PORT']
REDIS_LIST = os.environ['REDISLIST']

r = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0)

# Get the project ID from the environment variable set in
# the 'bigquery-controller.yaml' manifest.
PROJECT_ID = os.environ['PROJECT_ID']

def write_to_bq(bigquery):
    """Write the data to BigQuery in small chunks."""
    tweets = []
    CHUNK = 50  # The size of the BigQuery insertion batch.
    tweet = None
    mtweet = None
    count = 0
    count_max = 50000
    redis_errors = 0
    allowed_redis_errors = 3
    while count < count_max:
        while len(tweets) < CHUNK:
            # We'll use a blocking list pop -- it returns when there is
            # new data.
            res = None
            try:
                res = r.brpop(REDIS_LIST)
            except:
                print 'Problem getting data from Redis.'
                redis_errors += 1
                if redis_errors > allowed_redis_errors:
                    print "Too many redis errors: exiting."
                    return
                continue
            try:
                tweet = json.loads(res[1])
            except Exception, e:
                print e
                redis_errors += 1
                if redis_errors > allowed_redis_errors:
                    print "Too many redis-related errors: exiting."
                    return
                continue
            # First do some massaging of the raw data
            mtweet = utils.cleanup(tweet)
            # We only want to write tweets to BigQuery; we'll skip 'delete' and
            # 'limit' information.
            if 'delete' in mtweet:
                continue
            if 'limit' in mtweet:
                continue
            tweets.append(mtweet)
        # try to insert the tweets into bigquery
        response = utils.bq_data_insert(bigquery, PROJECT_ID, os.environ['BQ_DATASET'],
                             os.environ['BQ_TABLE'], tweets)
        tweets = []
        count += 1
        if count % 25 == 0:
            print ("processing count: %s of %s at %s: %s" %
                   (count, count_max, datetime.datetime.now(), response))

if __name__ == '__main__':
    print "starting write to BigQuery...."
    bigquery = utils.create_bigquery_client()
    write_to_bq(bigquery)

Como iniciar o aplicativo Kubernetes

Depois de criar e enviar por push a imagem Docker (opcionalmente), você pode iniciar o aplicativo Kubernetes.

No Kubernetes, as menores unidades implantáveis que podem ser criadas, programadas e gerenciadas são os pods, e não os contêineres de aplicativos individuais.

Um conjunto de réplicas garante que um número especificado de réplicas de pods seja executado em determinado momento. Se houver muitas réplicas, ele encerrará algumas. Se houver muito poucas, ele iniciará mais. Em vez de apenas criar pods de singleton ou até criar pods em massa, um conjunto de réplicas substitui os pods que são excluídos ou encerrados por qualquer motivo, como no caso de falha do nó.

Em uma implantação, você encontra atualizações declarativas para pods e conjuntos de réplicas. Basta descrever o estado desejado em um objeto de implantação. O controlador de implantação alterará o estado real para o estado desejado, a uma taxa controlada.

Você usará implantações para os pods do Redis para o BigQuery e do Twitter para o Redis.

Iniciar o pod Redis mestre

Inicie primeiro o pods Redis mestre. Se estiver curioso, veja o arquivo de especificações do pod Redis mestre em kube-redis-bq/redis/redis-master.yaml:

apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: redis-master
  labels:
    name: redis-master
spec:
  replicas: 1
  template:
    metadata:
      labels:
        name: redis-master
    spec:
      containers:
      - name: master
        image: redis
        ports:
        - containerPort: 6379
  1. Para iniciar o pod, execute este comando:

    kubectl create -f kube-redis-bq/redis/redis-master.yaml
    
  2. Execute o seguinte comando para verificar se o pod Redis mestre está sendo executado:

    kubectl get pods
    

Olhe o campo STATUS para verificar se o mestre está em execução. Talvez você veja também alguns outros pods já em execução. Esses pods extras são adicionados e usados pela biblioteca do Kubernetes.

Pode demorar cerca de 30 segundos para que o pod seja colocado em uma instância. Durante esse período, o pod Redis mestre listará seu respectivo host como <unassigned>. No entanto, o valor final de Host será o nome da instância em que o pod está sendo executado. Quando o processo for concluído, o status do pod mudará de ContainerCreating para Running.

Iniciar o serviço do Redis mestre

No Kubernetes, um serviço define um conjunto lógico de pods e uma política para acessá-los. O serviço é especificado em kube-redis-bq/redis/redis-master-service.yaml da seguinte maneira:

apiVersion: v1
kind: Service
metadata:
  name: redismaster
  labels:
    name: redis-master
spec:
  ports:
    # The port that this service should serve on.
    # You don't need to specify the targetPort if it is the same as the port,
    # though here we include it anyway, to show the syntax.
  - port: 6379
    targetPort: 6379
  selector:
    name: redis-master

O pod Redis que você criou acima tem o rótulo name: redis-master. O campo seletor do serviço determina quais pods receberão o tráfego enviado ao serviço.

  1. Insira o seguinte comando para iniciar o serviço:

    kubectl create -f kube-redis-bq/redis/redis-master-service.yaml
    
  2. Para ver os serviços em execução, insira este comando:

    kubectl get services
    

Iniciar a implantação do Redis para o BigQuery

Em seguida, inicie a implantação para os pods que extraem tweets do cache do Redis e os transmitem para a tabela do BigQuery.

Antes de iniciar a implantação, pode ser útil examinar mais atentamente o kube-redis-bq/redis/bigquery-controller.yaml. Esse arquivo define a implantação e especifica um conjunto de réplicas com duas réplicas de pod. As características desses pods replicados são definidas no arquivo por meio de um modelo de pod.

  1. Execute o comando a seguir para iniciar os pods replicados:

    kubectl create -f kube-redis-bq/redis/bigquery-controller.yaml
    
  2. Para verificar se os pods estão sendo executados, digite este comando:

    kubectl get pods
    

    Pode demorar cerca de 30 segundos para que os novos pods sejam movidos de ContainerCreating para Running . Você verá um pod Redis chamado redis-master e dois pods do BigQuery para o Redis chamados bigquery-controller.

  3. Para ver as implementações definidas pelo sistema e quantas réplicas cada uma delas deverá ter, execute o seguinte comando:

    kubectl get deployments
    

Iniciar a implantação do Twitter para Redis

Depois que os pods de pipeline do Redis mestre e do Redis para o BigQuery estiverem em execução, inicie a implantação que extrai os tweets e os adiciona ao cache do Redis. Assim como o kube-redis-bq/redis/bigquery-controller.yaml, o arquivo de especificação do Twitter para o Redis, kube-redis-bq/redis/twitter-stream.yaml, também define uma implantação. No entanto, desta vez, a implantação pede apenas um pod replicado, já que o Twitter só permite uma conexão de API de streaming ao mesmo tempo.

  1. Para iniciar a implantação, insira o seguinte comando:

    kubectl create -f kube-redis-bq/redis/twitter-stream.yaml
    
  2. Para verificar se todos os pods estão em execução, execute o comando a seguir. Mais uma vez, pode demorar cerca de 30 segundos para que o novo pod passe de ContainerCreating para Running.

    kubectl get pods
    

    Além dos pods que você viu na etapa anterior, aparecerá um novo pod com o marcador twitter-stream. Parabéns! O canal de análise está funcionando.

  3. Para ver as implementações definidas pelo sistema e quantas réplicas cada uma delas deverá ter, execute o seguinte comando:

    kubectl get deployments
    

    O resultado será semelhante a isto:

    NAME                   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
    bigquery-controller    2         2         2            2           2m
    twitter-stream         1         1         1            1           2m
    

Como consultar a tabela do BigQuery

Abra a IU da Web do BigQuery e clique em Compose Query para começar a escrever uma nova consulta. Para verificar se está funcionando, basta executar uma consulta simples da seguinte maneira:

SELECT
  text
FROM
  [rtda.tweets]
LIMIT
  1000 IGNORE CASE;

Deixe o canal coletar tweets por um tempo. Algumas horas devem bastar, mas quanto mais você deixá-lo funcionando, mais rico será o conjunto de dados. Depois que você tiver mais dados na tabela do BigQuery, tente executar algumas consultas de amostra interessantes.

Este exemplo de consulta demonstra como encontrar os tweets na tabela que foram reenviados mais vezes, filtrando por um termo específico (neste caso, “android”):

SELECT
  text,
  MAX(retweeted_status.retweet_count) AS max_retweets,
  retweeted_status.user.screen_name
FROM
  [rtda.tweets]
WHERE
  text CONTAINS 'android'
GROUP BY
  text,
  retweeted_status.user.screen_name
ORDER BY
  max_retweets DESC
LIMIT
  1000 IGNORE CASE;

Talvez seja interessante filtrar os tweets coletados por um conjunto de termos. Esta consulta filtra pelas palavras “Kubernetes”, “BigQuery”, “Redis” ou “Twitter”:

SELECT
  created_at,
  text,
  id,
  retweeted_status.retweet_count,
  user.screen_name
FROM
  [rtda.tweets]
WHERE
  text CONTAINS 'kubernetes'
  OR text CONTAINS 'BigQuery'
  OR text CONTAINS 'redis'
  OR text CONTAINS 'twitter'
ORDER BY
  created_at DESC
LIMIT
  1000 IGNORE CASE;

Esta consulta procura uma correlação entre o número de favoritos e o número de tweets reenviados no conjunto de tweets:

SELECT
  CORR(retweeted_status.retweet_count, retweeted_status.favorite_count),
  lang,
COUNT(*) c
FROM [rtda.tweets]
GROUP BY lang
HAVING c > 2000000
ORDER BY 1

Indo ainda mais fundo, você também pode investigar se os falantes de um determinado idioma preferem adicionar aos favoritos em vez de reenviar o tweet ou vice-versa:

SELECT
  CORR(retweeted_status.retweet_count, retweeted_status.favorite_count),
  lang,
COUNT(*) c,
AVG(retweeted_status.retweet_count) avg_rt,
AVG(retweeted_status.favorite_count) avg_fv,
AVG(retweeted_status.retweet_count)/AVG(retweeted_status.favorite_count) ratio_rt_fv
FROM [rtda.tweets]
WHERE retweeted_status.retweet_count > 1 AND retweeted_status.favorite_count > 1
GROUP BY lang
HAVING c > 1000000
ORDER BY 1;

Como fazer a limpeza

Os marcadores facilitam a seleção dos recursos que você quer parar ou excluir. Por exemplo:

kubectl delete deployment -l "name in (twitter-stream, bigquery-controller)"

Você também pode excluir um recurso usando o respectivo nome de arquivo de especificação. Por exemplo, exclua o serviço Redis e o controlador de replicação desta maneira:

kubectl delete -f redis-master.yaml
kubectl delete -f redis-master-service.yaml

Caso queira encerrar as instâncias do cluster, execute este comando:

kubernetes/cluster/kube-down.sh

Isso excluirá todas as instâncias do cluster.

Apêndice: como criar e enviar a imagem do Docker

Os pods do Kubernetes exigem uma imagem do Docker que inclua os scripts do aplicativo e as respectivas bibliotecas de suporte. Essa imagem é usada para iniciar os pods do Twitter para o Redis e do Redis para o BigQuery que fazem parte do canal de análise. O Dockerfile localizado no diretório kube-redis-bq/redis/redis-pipe-image especifica essa imagem da seguinte maneira:

FROM python:2

RUN pip install --upgrade pip
RUN pip install tweepy
RUN pip install --upgrade google-api-python-client
RUN pip install redis
RUN pip install python-dateutil

ADD twitter-to-redis.py /twitter-to-redis.py
ADD redis-to-bigquery.py /redis-to-bigquery.py
ADD controller.py /controller.py
ADD utils.py /utils.py

CMD python controller.py

Este Dockerfile primeiro instrui o daemon Docker a instalar algumas bibliotecas Python necessárias para a nova imagem:

  • tweepy, um wrapper do Python para a Twitter API
  • redis-py, um wrapper do Python para o Redis
  • as bibliotecas Python da API do Google
  • python-dateutil, uma extensão para o módulo datetime padrão de Python

Em seguida, são adicionados quatro scripts em redis-pipe-image:

  • controller.py: fornece um ponto de execução comum para os outros dois scripts Python na imagem do pipeline.
  • utils.py: contém algumas funções auxiliares.
  • redis-to-bigquery.py: transmite dados armazenados em cache do Redis para o BigQuery.
  • twitter-to-redis.py: transmite tweets recebidos do Twitter para o Redis.

  • Para criar a imagem do pipeline usando o Dockerfile associado, execute o comando a seguir. Substitua [PROJECT_ID] pelo código do projeto:

    sudo docker build -t gcr.io/[PROJECT_ID]/pipeline_image kube-redis-bq/redis/redis-pipe-image
    
  • Depois de criar a imagem, envie-a por push ao Google Container Registry para que o Kubernetes possa acessá-la. Substitua [PROJECT_ID] pelo código do projeto quando executar este comando:

    sudo gcloud docker -- push gcr.io/[PROJECT_ID]/pipeline_image
    

Atualizar os arquivos de especificação do Kubernetes para usar uma imagem personalizada

Em seguida, atualize os valores de image nos arquivos de especificação para usar a nova imagem. É preciso atualizar estes dois arquivos:

kube-redis-bq/redis/twitter-stream.yaml
kube-redis-bq/redis/bigquery-controller.yaml
  1. Edite cada arquivo e procure esta linha:

    gcr.io/google-samples/redis-bq-pipe:v3
    
  2. Substitua your-project pelo código do projeto. Substitua o nome da imagem por pipeline_image.

  3. Salve e feche os arquivos.

Próximas etapas

  • Conheça outros recursos do Google Cloud Platform. Veja nossos tutoriais.
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…