Indexer Twitter sur Found

Il y a quelques mois, j’expliquais dans ce billet comment on peut indexer Twitter en utilisant Logstash et Elasticsearch.

J’ai le même besoin aujourd’hui car je souhaite monitorer ce qui se passera sur Twitter lors de notre prochain Meetup Elastic FR. Venez nous rejoindre si vous êtes en France !

En réalité, le tutoriel que j’avais alors écrit peut être grandement simplifié et, en fait, je n’ai plus envie de perdre mon temps à construire, superviser et administrer mes clusters Elasticsearch et Kibana. Alors, j’utilise un cluster Found par Elastic à la place.

Créer votre cluster

Super simple. Connectez-vous à Found et suivez les instructions pour créer votre cluster. 
Found est toujours à jour avec les dernières versions d’Elasticsearch, alors ici, j’utilise un cluster en version 2.0.0.

Ajouter Kibana 4

Dans l’onglet configuration, il suffit juste d’activer Kibana 4 et le tour est joué! :D 
Ici c’est pareil, Kibana est toujours à jour alors j’utilise Kibana 4.2.1 qui vient tout juste de sortir !

Créer des utilisateurs Shield

Avec Found, vous bénéficiez automatiquement de toute la sécurité nécessaire pour opérer un cluster dans le cloud. 
En fait, vous n’avez qu’à vous occuper de la configuration (qui vient d’ailleurs avec de bonnes valeurs par défaut).

Je définis donc 3 rôles :

• kibana4admin: peut lire et écrire les dashboards Kibana
• kibana4: peut seulement lire les dashboards Kibana
• twitter: peut écrire des données dans n’importe quel index qui commence par twitter-

kibana4admin:
  cluster:
      - cluster:monitor/nodes/info
      - cluster:monitor/health
  indices:
    '*':
      - indices:admin/mappings/fields/get
      - indices:admin/validate/query
      - indices:data/read/search
      - indices:data/read/msearch
      - indices:admin/get
    '.kibana':
      - indices:admin/exists
      - indices:admin/mapping/put
      - indices:admin/mappings/fields/get
      - indices:admin/refresh
      - indices:admin/validate/query
      - indices:data/read/get
      - indices:data/read/mget
      - indices:data/read/search
      - indices:data/write/delete
      - indices:data/write/index
      - indices:data/write/update
      - indices:admin/create
kibana4:
  cluster:
      - cluster:monitor/nodes/info
      - cluster:monitor/health
  indices:
    '*':
      - indices:admin/mappings/fields/get
      - indices:admin/validate/query
      - indices:data/read/search
      - indices:data/read/msearch
      - indices:admin/get
    '.kibana':
      - indices:admin/exists
      - indices:admin/mappings/fields/get
      - indices:admin/validate/query
      - indices:data/read/get
      - indices:data/read/mget
      - indices:data/read/search
twitter:
  cluster:
    - indices:admin/template/get
    - indices:admin/template/put
  indices:
    '*':
      - indices:data/write/bulk
    'twitter-*':
      - indices:admin/create
      - indices:data/write/index

J’ajoute 3 utilisateurs :

kibana: password1
kibanaadmin: password2
logstash: password3

Et j’associe mes rôles et utilisateurs :

kibana4: kibana
kibana4admin: kibanaadmin
twitter: logstash

Il n’y a plus qu’à sauvegarder la configuration et Found est prêt à fonctionner !

Récupérer des données depuis Twitter

Pour l’instant, Found ne propose pas d’exécuter des clusters Logstash alors pour cette partie je créé ma propre instance sur Amazon. A noter qu’évidemment vous pouvez faire tourner cela sur n’importe quel cloud ou en local sur votre machine.

Application Twitter

Il faut avoir créé son application Twitter et avoir récupéré dans l’onglet “Keys and Access Tokens” les informations suivantes :

• consumer_key et consumer_secret (à générer si besoin).
• access_token et access_token_secret (à générer également si besoin).

Logstash

Sur mon instance, j’installe Logstash. Comme j’ai la toute dernière version d’Elasticsearch, je peux aussi bénéficier des apports de la dernière version de Logstash. J’utilise donc ici la version 2.0.0 :

wget https://download.elastic.co/logstash/logstash/logstash-2.0.0.tar.gz
tar xzf logstash-2.0.0.tar.gz

Ensuite, je créé un fichier de template Elasticsearch tel que je l’avais expliqué dans mon article précédent :

{
  "template": "twitter*",
  "order":    1, 
  "settings": {
    "number_of_shards": 1 
  },
  "mappings": {
    "tweet": { 
      "_all": {
        "enabled": false
      },
      "dynamic_templates" : [ {
         "message_field" : {
           "match" : "message",
           "match_mapping_type" : "string",
           "mapping" : {
             "type" : "string", "index" : "analyzed", "omit_norms" : true
           }
         }
       }, {
         "string_fields" : {
           "match" : "*",
           "match_mapping_type" : "string",
           "mapping" : {
             "type" : "string", "index" : "analyzed", "omit_norms" : true,
               "fields" : {
                 "raw" : {"type": "string", "index" : "not_analyzed", "ignore_above" : 256}
               }
           }
         }
       } ],
      "properties": {
        "text": {
          "type": "string"
        },
        "coordinates": {
          "properties": {
             "coordinates": {
                "type": "geo_point"
             },
             "type": {
                "type": "string"
             }
          }
       }
      }
    }
  }
}

Puis je créé mon fichier de configuration Logstash que je nomme ici meetup_fr.conf. Je vais traquer tout ce qui se dit sur elasticfr :

input {
  twitter {
      consumer_key => "consumer_key"
      consumer_secret => "consumer_secret"
      oauth_token => "access_token"
      oauth_token_secret => "access_token_secret"
      keywords => [ "elasticfr" ]
      full_tweet => true
  }
}
filter {
}
output {
  stdout { codec => dots }
  elasticsearch {
    ssl => true
    hosts => [ "MYCLUSTERONFOUND.found.io:9243" ]
    index => "twitter_meetup_fr_201511"
    document_type => "tweet"
    template => "twitter_template.json"
    template_name => "twitter"
    user => "logstash"
    password => "password3"
  }
}

Il n’y a plus qu’à lancer Logstash :

./logstash-2.0.0/bin/logstash -f meetup_fr.conf

Et à envoyer un tweet !

Analyser les tweets

Il n’y a plus qu’à ouvrir l’instance Kibana 4 qui tourne sur Found et à construire comme d’habitude les dashboards souhaités.

Notre tweet est là !