IMPORT PIKA

Prévia do material em texto

Bibliotecas RabbitMQ
RabbitMQ fala AMQP 0.9.1, que é, um protocolo de uso geral aberto para mensagens. 
Há um número de clientes para RabbitMQ em muitas línguas diferentes. 
Nesta série tutorial vamos usar Pika, que é o cliente Python recomendado pela equipe RabbitMQ. Para instalá-lo, você pode usar a ferramenta de gerenciamento de pacotes pip.
Sending
Nossa send.py primeiro programa irá enviar uma única mensagem para a fila. A primeira coisa que precisamos fazer é estabelecer uma conexão com o servidor RabbitMQ.
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
 'localhost'))
channel = connection.channel()
Estamos ligados agora, a um corretor na máquina local - daí o localhost. Se quiséssemos para se conectar a um corretor em uma máquina diferente teríamos basta especificar o nome ou o endereço IP aqui.
Em seguida, antes de enviar precisamos ter certeza existe a fila de destinatário. Se enviar uma mensagem para local não-existente, RabbitMQ será apenas lixo a mensagem. Vamos criar uma fila para a qual a mensagem será entregue, vamos nomeá-lo Olá:
channel.queue_declare(queue='hello')
Nesse ponto estamos prontos para enviar uma mensagem. Nossa primeira mensagem só vai conter uma cadeia Olá mundo! e queremos enviá-lo para a nossa fila Olá.
Em RabbitMQ uma mensagem nunca pode ser enviada diretamente para a fila, ele sempre precisa passar por uma troca. Mas não vamos ficar arrastado para baixo pelos detalhes - você pode ler mais sobre as trocas na terceira parte deste tutorial. Tudo o que precisamos saber agora é como usar uma troca padrão identificado por uma cadeia vazia. Esta troca é especial - ela nos permite especificar exatamente a que a fila a mensagem deve ir. O nome da fila precisa ser especificado no parâmetro routing_key:
channel.basic_publish(exchange='',
 routing_key='hello',
 body='Hello World!')
print(" [x] Sent 'Hello World!'")
Antes de sair do programa que precisamos para garantir que os buffers a rede estavam vermelhas e nossa mensagem foi efectivamente entregue ao RabbitMQ. Podemos fazê-lo, fechando delicadamente a conexão.
connection.close()
Receiving
Nossa receive.py segundo programa receberá mensagens da fila e imprimi-los na tela.
Mais uma vez, primeiro precisamos conectar ao servidor RabbitMQ. O código responsável pela ligação ao coelho é o mesmo que anteriormente.
O próximo passo, como antes, é ter certeza de que existe a fila. Criação de uma fila usando queue_declare é idempotente - podemos executar o comando quantas vezes nós gostamos, e apenas um será criado.
channel.queue_declare(queue='hello')
Você pode perguntar por que nós declaramos a fila novamente - já declarou que em nosso código anterior. Poderíamos evitar que, se tivéssemos certeza de que a fila já existe. Por exemplo se o programa send.py foi executado antes. Mas ainda não tem certeza de qual programa a ser executado pela primeira vez. Em tais casos, é uma boa prática para repetir declarando a fila em ambos os programas.
Listing queues
You may wish to see what queues RabbitMQ has and how many messages are in them. You can do it (as a privileged user) using the rabbitmqctl tool:
$ sudo rabbitmqctl list_queues
Listing queues ...
hello 0
...done.
Putting it all together
Full code for send.py:
	 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
	#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
 host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
channel.basic_publish(exchange='',
 routing_key='hello',
 body='Hello World!')
print(" [x] Sent 'Hello World!'")
connection.close()
(send.py source)
Full receive.py code:
	 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
	#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
 host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
 print(" [x] Received %r" % body)
channel.basic_consume(callback,
 queue='hello',
 no_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
(receive.py source)
Now we can try out our programs in a terminal. First, let's send a message using our send.pyprogram:
 $ python send.py
 [x] Sent 'Hello World!'
The producer program send.py will stop after every run. Let's receive it:
 $ python receive.py
 [*] Waiting for messages. To exit press CTRL+C
 [x] Received 'Hello World!'
Hurray! We were able to send our first message through RabbitMQ. As you might have noticed, the receive.py program doesn't exit. It will stay ready to receive further messages, and may be interrupted with Ctrl-C.
Try to run send.py again in a new terminal.
We've learned how to send and receive a message from a named queue. It's time to move on topart 2 and build a simple work queue.