Fila (fila) — uma estrutura de dados em disco ou na memória que armazena referências a mensagens e fornece suas cópias. consumidores (a consumidores). Fila representa com estado (onde as próprias mensagens podem ser armazenadas em cache). Mil filas podem ocupar cerca de 80 Mb.
Binding (vinculação) — uma regra que informa ao intercambiador em qual fila as mensagens devem ser direcionadas.
Índice
- RabbitMQ. Parte 4. Entendendo o que são mensagens e frames
- RabbitMQ. Parte 5. Desempenho da publicação e consumo de mensagens
- RabbitMQ. Parte 6. Visão geral dos módulos Federation e Shovel
- RabbitMQ. Parte 7. Detalhes sobre Connection e Channel
- RabbitMQ. Parte 8. RabbitMQ no .NET
- RabbitMQ. Parte 9. Monitoramento
Filas temporárias
Se a criação da fila ocorre com o parâmetro definido autoDelete, essa fila adquire a capacidade de se autodeletar. Essas filas geralmente são criadas no momento da conexão do primeiro cliente e excluídas quando todos os clientes se desconectam.
Se a criação da fila ocorre com o parâmetro definido exclusivo, então essa fila permite que apenas um consumidor se conecte e se exclui se o canal for fechado. Enquanto o canal não for fechado, o cliente pode desconectar/conectar, mas somente dentro da mesma conexão. Se o parâmetro exclusivo estiver definido, o parâmetro autoDelete não terá efeito algum.
Características:
- com desconexões breves, perderemos mensagens que ainda não chegaram ao consumidor
- podemos observar o fenômeno
binding churn. O fenômeno ocorre quando o número de operações de criação/exclusão de filas e vínculos atinge valores muito altos. No modo cluster, esse fluxo de operações se espalhará por todos os nós e criará uma grande carga. Esse processo pode ser otimizado controlando o número de assinaturas.
Filas permanentes
Se a criação da fila ocorre com o parâmetro definido durável, então essa fila mantêm seu estado e se recuperam após a reinicialização do servidor/intermediário. Essa fila existirá até que o comando Queue.Delete.
Filas Altamente Disponíveis
Filas HA requerem um ambiente de cluster RabbitMQ. No modo cluster, todas as informações sobre intercambiadores, filas, vínculos e consumidores serão copiadas para todos os nós.
Quando uma mensagem é publicada em uma fila HA, ela é armazenada em cada nó relacionado à fila HA. Depois que a mensagem é consumida em um dos nós, todas as cópias dessa mensagem serão excluídas em outros nós.
As filas HA podem se espalhar por todos os nós em um determinado cluster ou apenas em nós individuais.
Características:
- O uso de filas HA leva a penalizações em desempenho. Ao colocar uma mensagem em uma fila HA ou ao consumir uma mensagem de uma fila HA, o RabbitMQ deve coordenar entre todos os nós (2-3 nós geralmente são suficientes)
Criação de fila
A criação da fila é feita através de um processo síncrono RPC ao servidor. A solicitação é feita pelo método Queue.Declare, invocando com os parâmetros:
- nome da fila
- outros parâmetros
Exemplo de criação de uma fila usando :
// ...
channel.QueueDeclare(
queue: "my_queue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null
);
// ...fila— nome da fila que queremos criar. O nome deve ser único e não pode coincidir com o nome do sistema da filadurável— se true, a fila será manter seu estado e será restaurada após a reinicialização do servidor/brokerexclusivo— se true, a fila permitirá a conexão apenas de um consumidorautoDelete— se true, a fila adquirirá a capacidade de se autodeletararguments— argumentos opcionais. Vamos explorar mais adiante.
arguments
x-message-ttl(x-message-time-to-live) — permite definir o tempo de vida da mensagem em milissegundos. Se a criação da fila ocorre com um valor de argumento definidox-message-ttl, então tal fila irá excluir automaticamente mensagens que tenham expirado. A configuração do valor do argumentox-message-ttldefine a idade máxima para todas as mensagens nesta fila. Criar tal fila ajuda a evitar a recepção de informações desatualizadas. Isso pode ser usado em sistemas em tempo real. Se uma fila tem uma troca para mensagens rejeitadas e um valor de argumento é definidox-message-ttl, então mensagens rejeitadas nesta fila começarão a ter um tempo de vida.x-expires— define um valor em milissegundos após o qual a fila será removida. A fila pode expirar apenas se não tiver assinantes. Se houver assinantes conectados à fila, ela só poderá ser removida automaticamente quando todos os assinantes chamaremBasic.Cancelou se desconectarem. O tempo de vida da fila só pode terminar se não houver solicitação paraBasic.Get. Caso contrário, o valor atual da configuração de tempo de vida é redefinido, e a fila não será mais removida automaticamente. Também não há garantias sobre quão rápido ocorre a remoção da fila após o término do seu tempo de vida.x-max-length— define o número máximo de mensagens na fila. Se o número de mensagens na fila começar a exceder o valor máximo, as mensagens mais antigas começarão a ser removidas
x-max-length-bytes— define o tamanho total máximo permitido da carga útil das mensagens na fila. Se o valor estabelecido for ultrapassado (ocorreu um estouro na fila durante a publicação de uma mensagem), as mensagens mais antigas começarão a ser removidasx-overflow— este argumento é utilizado para configurar o comportamento em caso de estouro da fila. Dois valores estão disponíveis:drop-head(valor padrão) ereject-publish. Se você escolherdrop-head, as mensagens mais antigas serão removidas. Se escolherreject-publish, a aceitação de mensagens será suspensax-dead-letter-exchange— define o exchange para onde as mensagens rejeitadas, que não foram colocadas de volta na fila, são direcionadasx-dead-letter-routing-key— define uma chave de roteamento opcional para as mensagens rejeitadasx-max-priority— permite a ordenação por prioridades na fila com um valor máximo de prioridade de 255 (RabbitMQ versões 3.5.0 e superior). O número indica a prioridade máxima que a fila suportará. Se o argumento não for definido, a fila não suportará a prioridade das mensagensx-queue-mode— permite colocar a fila em modo preguiçoso. Nesse modo, o máximo de mensagens será armazenado no disco. O uso da memória RAM será mínimo. Se não estiver definido, a fila armazenará mensagens na memória para entregar mensagens o mais rápido possívelx-queue-master-locator— se tivermos um cluster, pode-se definir a fila mestrex-ha-policy— utilizado na criação de filas HA e define como a mensagem será distribuída pelos nós. Se o valor for definido comoall, a mensagem será mantida em todos os nós. Se o valor for definido comonodes, a mensagem será mantida em nós específicos do clusterx-ha-nodes— define os nós aos quais uma determinada fila se referiráHA
Se a criação da fila talvez, o servidor enviará ao cliente uma resposta síncrona RPC uma resposta Queue.DeclareOk. Se a criação da fila é impossível (ocorreu um erro na solicitação Queue.Declare), então o canal será fechado for feita pelo servidor usando o comando Channel.Close e o cliente receberá uma exceção , que conterá o código de erro e sua descrição.
Uma nova chamada Queue.Declare com os mesmos parâmetros retornará informações úteis sobre esta fila. Por exemplo, o número total de mensagens aguardando nesta fila e o número total de consumidores que assinaram ela.
Chamada Queue.Declare com as credenciais de um usuário que não tem as permissões necessárias fechará o canal com o comando Channel.Close e o cliente receberá uma exceção , que conterá o código de erro e sua descrição.
Depois que a fila estiver ociosa por >= 10 segundos, ela entra em modo de espera, chamando o GC na fila, o que resulta em uma redução significativa da memória necessária para essa fila.
Criação de Queue através da interface gráfica
Acesse o painel do administrador RabbitMQ como usuário guest (username: guest e password: guest). Observe que o usuário guest pode se conectar apenas a partir do host local. Agora vamos para a aba Filas e clique em Adicionar uma nova fila. Preencha as propriedades:
Assim que inserirmos todos os dados necessários e clicarmos em Adicionar filas, a fila aparecerá na lista geral.
Um clique no nome da fila mostrará suas informações detalhadas. Aqui, você pode configurar a ligação entre a troca e a fila, ver a lista consumidores, publicar/pegar mensagens, excluir a fila e ver as estatísticas.
Criação de Binding
A criação de uma ligação ocorre através de um RPC ao servidor. A solicitação é feita pelo método Queue.Bind, invocando com os parâmetros:
- nome da fila
- nome do ponto de troca
- outros parâmetros
Exemplo de criação de ligação usando :
//...
channel.QueueBind(
queue: queueName,
exchange: "my_exchange",
routingKey: "my_key",
arguments: null
);
//...fila— nome da filaexchange— nome do corretorroutingKey— chave de roteamentoarguments— argumentos opcionais
Se a criação da ligação talvez, o servidor enviará ao cliente uma resposta síncrona RPC uma resposta Queue.BindOk.
Criação de Binding através da interface gráfica
Acesse o painel do administrador RabbitMQ como usuário guest (username: guest e password: guest). Observe que o usuário guest pode se conectar apenas a partir do host local. Agora vamos para a aba Filas e clicamos na fila my_queue. Preenchemos os campos da seção binds:
Assim que inserirmos todos os dados necessários e clicarmos em Bind, a ligação aparecerá na lista geral:
Código
Nesta seção, descreveremos a fila e a ligação usando código C#, como se precisássemos desenvolver uma biblioteca. Isso pode ser útil para compreensão.
public interface IQueue
{
string Name { get; }
// <summary>
// Se definido como true, a fila será durável.
// Ela será armazenada no disco e poderá
// sobreviver a uma reinicialização do servidor/corretor.
// Se o valor for false, a fila é temporária e será excluída,
// quando o servidor/corretor for reiniciado
// </summary>
bool IsDurable { get; }
// <summary>
// Se o valor for true,
// essa fila permitirá conectar-se
// apenas a um consumidor
// </summary>
bool IsExclusive { get; }
// <summary>
// Exclusão automática.
// A fila será excluída quando todos os clientes se desconectarem.
// </summary>
bool IsAutoDelete { get; }
// <summary>
// Argumentos opcionais
// </summary>
IDictionary<string, object> Arguments { get; }
}class pública Queue : IQueue
{
public Queue(
string name,
bool isDurable = true,
bool isExclusive = false,
bool isAutoDelete = false,
IDictionary arguments = null)
{
Name = name ??
throw new ArgumentNullException(name, $"{name} não pode ser nulo");
IsDurable = isDurable;
IsExclusive = isExclusive;
IsAutoDelete = isAutoDelete;
Arguments = arguments ?? new Dictionary();
}
public string Name { get; }
public bool IsDurable { get; }
public bool IsExclusive { get; }
public bool IsAutoDelete { get; }
public IDictionary Arguments { get; }
}class pública QueueMode
{
public const string Default = "default";
// <summary>
// Modo preguiçoso. O modo preguiçoso fará com que
// o máximo possível de mensagens seja salvo em disco
// para reduzir o uso da memória
// </summary>
public const string Lazy = "lazy";
}interface pública IBinding
{
// <summary>
// O intercâmbio que será vinculado à ligação
// </summary>
IExchange Exchange { get; }
// <summary>
// Chave de roteamento
// </summary>
string RoutingKey { get; }
// <summary>
// Argumentos opcionais
// </summary>
IDictionary Arguments { get; }
}class pública Binding : IBinding
{
public Binding(
IExchange exchange,
string routingKey,
IDictionary arguments)
{
Exchange = exchange;
RoutingKey = routingKey;
Arguments = arguments;
}
public IExchange Exchange { get; }
public string RoutingKey { get; }
public IDictionary Arguments { get; }
}Fonte: habr.com
