Snabbstart: Skicka händelser till Azure Event Hubs med C

  • Artikel

Introduktion

Azure Event Hubs är en strömningstjänst för stordata och händelseinmatningstjänst som kan ta emot och bearbeta flera miljoner händelser per sekund. Event Hubs kan bearbeta och lagra händelser, data eller telemetri som producerats av distribuerade program och enheter. Data som skickas till en händelsehubb kan omvandlas och lagras med valfri provider för realtidsanalys eller batchbearbetnings-/lagringsadapter. En detaljerad översikt över Event Hubs finns i Översikt över Event Hubs och Event Hubs-funktioner.

I den här självstudien beskrivs hur du skickar händelser till en händelsehubb med hjälp av ett konsolprogram i C.

Förutsättningar

För att göra den här självstudien behöver du följande:

  • En C-utvecklingsmiljö. I den här självstudien förutsätts gcc-stacken på en virtuell Azure Linux-dator med Ubuntu 14.04.
  • Microsoft Visual Studio.
  • Skapa ett Event Hubs-namnområde och en händelsehubb. Använd Azure-portalen för att skapa ett namnområde av typen Event Hubs och hämta de autentiseringsuppgifter för hantering som programmet behöver för att kommunicera med händelsehubben. Om du behöver skapa ett namnområde och en händelsehubb följer du anvisningarna i den här artikeln. Hämta värdet för åtkomstnyckeln för händelsehubben genom att följa anvisningarna i artikeln: Hämta anslutningssträng. Du använder åtkomstnyckeln i koden som du skriver senare i den här självstudien. Standardnyckelnamnet är: RootManageSharedAccessKey.

Skriva kod för att skicka meddelanden till Event Hubs

I det här avsnittet visas hur du skriver en C-app för att skicka händelser till din händelsehubb. Koden använder Proton AMQP-biblioteket från Apache Qpid-projektet. Detta är detsamma som att använda Service Bus-köer och ämnen med AMQP från C enligt det här exemplet. Mer information finns i Qpid Proton-dokumentationen.

  1. Från sidan Qpid AMQP Messenger följer du anvisningarna för att installera Qpid Proton, beroende på din miljö.

  2. Installera följande paket för att kompilera Proton-biblioteket:

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

  3. Ladda ned Qpid Proton-biblioteket och extrahera det, till exempel:

    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. Skapa en byggkatalog, kompilera och installera:

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

  5. I arbetskatalogen skapar du en ny fil med namnet sender.c med följande kod. Kom ihåg att ersätta värdena för din SAS-nyckel/ditt namn, händelsehubbens namn och namnområde. Du måste också ersätta en URL-kodad version av nyckeln med den SendRule som skapades tidigare. Du kan URL-koda den här.

    #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. Kompilera filen, förutsatt att gcc:

    gcc sender.c -o sender -lqpid-proton

    Kommentar

    Den här koden använder ett utgående fönster på 1 för att tvinga ut meddelandena så snart som möjligt. Vi rekommenderar att programmet försöker skicka batchmeddelanden för att öka dataflödet. Se Qpid AMQP Messenger-sidan för information om hur du använder Qpid Proton-biblioteket i den här och andra miljöer och från plattformar för vilka bindningar tillhandahålls (för närvarande Perl, PHP, Python och Ruby).

Kör programmet för att skicka meddelanden till händelsehubben.

Grattis! Du har nu skickat meddelanden till en händelsehubb.

Nästa steg

Läs följande artiklar: