Guia de início rápido: enviar eventos aos Hubs de Eventos do Azure usando a linguagem C

  • Artigo

Introdução

Os Hubs de Eventos do Azure são uma plataforma de streaming de Big Data e um serviço de ingestão de eventos capaz de receber e processar milhões de eventos por segundo. Os Hubs de Eventos podem processar e armazenar eventos, dados ou telemetria produzidos pelos dispositivos e software distribuídos. Os dados enviados para um Hub de Eventos podem ser transformados e armazenados usando qualquer provedor de análise em tempo real ou adaptadores de envio em lote/armazenamento. Para obter uma visão detalhada dos Hubs de Eventos, confira Visão geral de Hubs de Eventos e Recursos de Hubs de Eventos.

Este tutorial descreve como enviar eventos para um hub de eventos usando um aplicativo de console em C.

Pré-requisitos

Para concluir este tutorial, você precisará do seguinte:

  • Um ambiente de desenvolvimento C. Este tutorial considera a pilha gcc em uma VM Linux do Azure com o Ubuntu 14.04.
  • Microsoft Visual Studio.
  • Criar um namespace de Hubs de Eventos e um hub de eventos. Use o portal do Azure para criar um namespace do tipo Hubs de Eventos e obter as credenciais de gerenciamento que seu aplicativo precisa para se comunicar com o hub de eventos. Para criar um namespace e um hub de eventos, siga o procedimento nesse artigo. Obtenha o valor da chave de acesso para o hub de eventos seguindo as instruções do artigo: Obter uma cadeia de conexão. A chave de acesso será usada no código que você escreverá posteriormente no tutorial. O nome da chave padrão é: RootManageSharedAccessKey.

Escrever código para enviar mensagens aos Hubs de Eventos

Esta seção mostra como gravar um aplicativo em C para enviar eventos ao hub de eventos. O código usa a biblioteca Proton AMQP do projeto Apache Qpid. Isso é semelhante a usar tópicos e filas do Barramento de Serviço com AMQP do C, como é mostrado neste exemplo. Para obter mais informações, consulte a Documentação do Qpid Proton.

  1. Na página Qpid AMQP Messenger, siga as instruções para instalar o Qpid Proton, de acordo com o ambiente.

  2. Para compilar a biblioteca Proton, instale os pacotes a seguir:

    sudo apt-get install build-essential cmake uuid-dev openssl libssl-dev

  3. Baixe a biblioteca Qpid Proton e extraia-a, por exemplo:

    wget https://archive.apache.org/dist/qpid/proton/0.7/qpid-proton-0.7.tar.gz
tar xvfz qpid-proton-0.7.tar.gz

  4. Crie um diretório de compilação, compile e instale:

    cd qpid-proton-0.7
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=/usr ..
sudo make install

  5. No seu diretório de trabalho, crie um novo arquivo chamado sender.c com o código a seguir. Lembre-se de substituir os valores de chave/nome de SAS, de nome do hub de eventos e de namespace. Você também deve substituir uma versão codificada em URL da chave para o SendRule criado anteriormente. Você pode codificar a URL aqui.

    #include "proton/message.h"
#include "proton/messenger.h"

#include <getopt.h>
#include <proton/util.h>
#include <sys/time.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>

volatile sig_atomic_t stop = 0;

#define check(messenger)                                                     \
  {                                                                          \
    if(pn_messenger_errno(messenger))                                        \
    {                                                                        \
      printf("check\n");                                                     \
      die(__FILE__, __LINE__, pn_error_text(pn_messenger_error(messenger))); \
    }                                                                        \
  }

void interrupt_handler(int signum){
  if(signum == SIGINT){
    stop = 1;
  }
}

pn_timestamp_t time_now(void)
{
  struct timeval now;
  if (gettimeofday(&now, NULL)) pn_fatal("gettimeofday failed\n");
  return ((pn_timestamp_t)now.tv_sec) * 1000 + (now.tv_usec / 1000);
}

void die(const char *file, int line, const char *message)
{
  printf("Dead\n");
  fprintf(stderr, "%s:%i: %s\n", file, line, message);
  exit(1);
}

int sendMessage(pn_messenger_t * messenger) {
    char * address = (char *) "amqps://{SAS Key Name}:{SAS key}@{namespace name}.servicebus.windows.net/{event hub name}";
    char * msgtext = (char *) "Hello from C!";

    pn_message_t * message;
    pn_data_t * body;
    message = pn_message();

    pn_message_set_address(message, address);
    pn_message_set_content_type(message, (char*) "application/octect-stream");
    pn_message_set_inferred(message, true);

    body = pn_message_body(message);
    pn_data_put_binary(body, pn_bytes(strlen(msgtext), msgtext));

    pn_messenger_put(messenger, message);
    check(messenger);
    pn_messenger_send(messenger, 1);
    check(messenger);

    pn_message_free(message);
}

int main(int argc, char** argv) {
    printf("Press Ctrl-C to stop the sender process\n");
    signal(SIGINT, interrupt_handler);

    pn_messenger_t *messenger = pn_messenger(NULL);
    pn_messenger_set_outgoing_window(messenger, 1);
    pn_messenger_start(messenger);

    while(!stop) {
        sendMessage(messenger);
        printf("Sent message\n");
        sleep(1);
    }

    // release messenger resources
    pn_messenger_stop(messenger);
    pn_messenger_free(messenger);

    return 0;
}

  6. Compile o arquivo, supondo que gcc:

    gcc sender.c -o sender -lqpid-proton

    Observação

    Esse código usa uma janela de saída igual a 1 para forçar o envio de mensagens assim que possível. É recomendável que o aplicativo tente enviar mensagens em lote para aumentar a produtividade. Confira a página Qpid AMQP Messenger para obter informações sobre como usar a biblioteca Qpid Proton neste e em outros ambientes e de plataformas para as quais associações são fornecidas (atualmente Perl, PHP, Python e Ruby).

Executar o aplicativo para enviar mensagens ao hub de eventos.

Parabéns! Agora você enviou mensagens para um hub de eventos.

Próximas etapas

Leia os seguintes artigos: