# Action Cable e WebSockets no Rails: Guia Completo para Entrevistas Técnicas > Domine Action Cable e WebSockets no Ruby on Rails para entrevistas tecnicas. Aprenda configuracao de conexoes, canais, Solid Cable, Turbo Streams, escalabilidade com Redis e estrategias de teste com exemplos praticos de codigo. - Published: 2026-05-07 - Updated: 2026-05-07 - Author: Anthony Fillion-Maillet - Tags: ruby on rails, action cable, websockets, tempo real, solid cable, rails 8 - Reading time: 11 min --- A comunicação em tempo real tornou-se um requisito fundamental em aplicações web modernas. Chats, notificações instantâneas, dashboards com atualização automática e colaboração simultânea são funcionalidades que os usuários esperam como padrão. No ecossistema Ruby on Rails, o Action Cable oferece uma solução elegante e integrada para implementar WebSockets, eliminando a necessidade de bibliotecas externas ou configurações complexas. Profissionais que dominam essa tecnologia destacam-se em processos seletivos, pois demonstram capacidade de construir aplicações responsivas e escaláveis. > Em entrevistas técnicas sobre Rails, questões sobre Action Cable frequentemente avaliam não apenas o conhecimento sintático, mas também a compreensão de arquitetura de sistemas distribuídos, gerenciamento de conexões e estratégias de escalabilidade. Preparar-se com exemplos práticos de implementação faz diferença significativa. ## Fundamentos do Action Cable e Arquitetura WebSocket O Action Cable foi introduzido no Rails 5 como uma solução full-stack para WebSockets. Diferentemente das requisições HTTP tradicionais, que seguem o modelo request-response, os WebSockets estabelecem uma conexão persistente bidirecional entre cliente e servidor. Essa arquitetura permite que o servidor envie dados ao cliente a qualquer momento, sem necessidade de polling. A arquitetura do Action Cable baseia-se em três componentes principais: conexões, canais e streams. As conexões representam o link WebSocket entre o cliente e o servidor, gerenciando autenticação e estado. Os canais funcionam como controllers especializados para comunicação em tempo real, encapsulando a lógica de negócio. Os streams permitem que múltiplos clientes recebam as mesmas transmissões, criando um mecanismo eficiente de pub/sub. O processo de estabelecimento de conexão inicia quando o cliente JavaScript solicita uma conexão WebSocket. O servidor Rails valida a requisição, autentica o usuário e mantém a conexão aberta para comunicação contínua. Cada conexão pode se inscrever em múltiplos canais simultaneamente. ## Configuração e Autenticação de Conexões A autenticação constitui a primeira linha de defesa em aplicações com WebSockets. O Action Cable oferece um mecanismo robusto para verificar a identidade do usuário antes de permitir qualquer comunicação. A classe Connection centraliza essa responsabilidade. ```ruby # app/channels/application_cable/connection.rb module ApplicationCable class Connection < ActionCable::Connection::Base identified_by :current_user def connect self.current_user = find_verified_user end private def find_verified_user if verified_user = User.find_by(id: cookies.encrypted[:user_id]) verified_user else reject_unauthorized_connection end end end end ``` O método `identified_by` define um identificador único para cada conexão, permitindo que o Action Cable rastreie quais usuários estão conectados. O cookie criptografado garante que a autenticação não possa ser falsificada por clientes maliciosos. Quando a verificação falha, `reject_unauthorized_connection` encerra a tentativa de conexão imediatamente. Entrevistadores frequentemente questionam sobre alternativas de autenticação, como tokens JWT ou sessões. A escolha depende da arquitetura da aplicação, mas cookies criptografados oferecem simplicidade e segurança adequadas para a maioria dos casos. ## Implementação de Canais e Lógica de Negócio Os canais encapsulam a lógica específica de cada funcionalidade em tempo real. Um canal de chat, por exemplo, gerencia inscrições em salas, recebimento de mensagens e notificação de presença. ```ruby # app/channels/chat_channel.rb class ChatChannel < ApplicationCable::Channel def subscribed room = ChatRoom.find(params[:room_id]) if room.members.include?(current_user) stream_for room else reject end end def receive(data) message = ChatMessage.create!( room_id: params[:room_id], user: current_user, body: data["body"] ) ChatChannel.broadcast_to( message.room, { id: message.id, body: message.body, user: current_user.name } ) end def unsubscribed AppearanceTracker.mark_offline(current_user) end end ``` O callback `subscribed` executa quando um cliente tenta se inscrever no canal. A verificação de membership impede que usuários não autorizados acessem salas privadas. O método `stream_for` configura o stream baseado em um objeto Active Record, gerando automaticamente um identificador único. O método `receive` processa mensagens enviadas pelo cliente. Após persistir a mensagem no banco de dados, `broadcast_to` distribui o conteúdo para todos os inscritos na sala. Essa separação entre recebimento e broadcast é crucial para garantir consistência de dados. O callback `unsubscribed` permite executar lógica de limpeza quando um usuário desconecta. Rastrear status de presença demonstra compreensão de padrões comuns em aplicações de tempo real. ## Integração com JavaScript no Cliente O lado cliente do Action Cable utiliza JavaScript para estabelecer conexões e reagir a eventos. A API oferece hooks para cada etapa do ciclo de vida da conexão. ```javascript // app/javascript/channels/chat_channel.js import consumer from "./consumer" const chatChannel = consumer.subscriptions.create( { channel: "ChatChannel", room_id: roomId }, { connected() { console.log("Connected to chat room", roomId) }, disconnected() { console.log("Disconnected from chat room") }, received(data) { const messageList = document.getElementById("messages") messageList.insertAdjacentHTML("beforeend", `
${data.user}: ${data.body}
` ) }, sendMessage(body) { this.perform("receive", { body: body }) } } ) ``` O objeto consumer gerencia a conexão WebSocket subjacente, enquanto subscriptions representa os canais ativos. O método `create` aceita parâmetros que são passados ao callback `subscribed` no servidor. Os callbacks `connected` e `disconnected` permitem atualizar a interface conforme o estado da conexão. O callback `received` processa dados enviados pelo servidor, possibilitando atualizações instantâneas na DOM. O método personalizado `sendMessage` encapsula a chamada a `perform`, que invoca métodos no canal do servidor. Essa abstração mantém o código organizado e facilita testes unitários. ## Solid Cable: A Nova Opção Padrão do Rails 8 O Rails 8 introduziu o Solid Cable como adaptador padrão para ambientes de desenvolvimento e produção de menor escala. Essa solução utiliza o próprio banco de dados relacional para gerenciar mensagens, eliminando a dependência do Redis em cenários onde a simplicidade é prioritária. ```yaml # config/cable.yml (Rails 8 default) development: adapter: solid_cable production: adapter: solid_cable connects_to: database: writing: cable polling_interval: 0.1.seconds message_retention: 1.day ``` O Solid Cable armazena mensagens temporariamente em uma tabela dedicada, utilizando polling eficiente para distribuição. A configuração `polling_interval` controla a frequência de verificação, enquanto `message_retention` define por quanto tempo mensagens são mantidas antes da limpeza automática. Para aplicações com múltiplos bancos de dados, a configuração separa o banco principal do banco de cable, evitando contenção de recursos. ```ruby # config/database.yml (Rails 8 multi-database) production: primary: <<: *default database: myapp_production cable: <<: *default database: myapp_cable_production migrations_paths: db/cable_migrate ``` Essa separação demonstra conhecimento avançado de arquitetura Rails, um diferencial em entrevistas para posições seniores. ## Padrões de Broadcasting e Integração com Jobs Transmissões podem originar de diversos pontos da aplicação, não apenas de canais. Callbacks de modelos e jobs em background representam cenários comuns para broadcasting assíncrono. ```ruby # Broadcasting from a model callback class Notification < ApplicationRecord belongs_to :user after_create_commit :broadcast_to_user private def broadcast_to_user ActionCable.server.broadcast( "notifications_#{user_id}", { id: id, title: title, read: false } ) end end # Broadcasting from a background job class DashboardUpdateJob < ApplicationJob queue_as :default def perform(dashboard_id) dashboard = Dashboard.find(dashboard_id) stats = dashboard.compute_stats ActionCable.server.broadcast( "dashboard_#{dashboard_id}", { stats: stats, updated_at: Time.current.iso8601 } ) end end ``` O broadcasting a partir de callbacks garante que clientes recebam atualizações imediatamente após alterações no banco de dados. Jobs em background permitem computações pesadas sem bloquear o ciclo de requisição, distribuindo resultados quando prontos. A convenção de nomenclatura de streams com prefixo e ID (`notifications_#{user_id}`) facilita o gerenciamento de múltiplos streams por tipo de recurso. ## Turbo Streams: Integração Moderna com Hotwire O Turbo Streams, componente do Hotwire, simplifica drasticamente a implementação de atualizações em tempo real. A integração com Action Cable ocorre de forma declarativa, reduzindo código boilerplate. ```ruby # app/models/message.rb class Message < ApplicationRecord belongs_to :chat_room broadcasts_to :chat_room end # app/views/chat_rooms/show.html.erb <%= turbo_stream_from @chat_room %>
<%= render @chat_room.messages %>
``` A macro `broadcasts_to` configura automaticamente callbacks para criar, atualizar e destruir registros, transmitindo fragmentos HTML renderizados. No view, `turbo_stream_from` estabelece a inscrição no canal correspondente. Essa abordagem elimina a necessidade de JavaScript personalizado para casos de uso comuns. Entrevistadores valorizam candidatos que conhecem tanto a API de baixo nível quanto abstrações modernas como Turbo Streams. ## Configuração Redis para Produção de Alta Escala Aplicações com milhares de conexões simultâneas ou múltiplos servidores requerem Redis como adaptador. O Redis oferece performance superior e suporta arquiteturas distribuídas. ```ruby # config/cable.yml — Redis adapter for high-scale production production: adapter: redis url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %> channel_prefix: myapp_production ``` O `channel_prefix` isola streams de diferentes aplicações que compartilham a mesma instância Redis. Variáveis de ambiente mantêm credenciais fora do código versionado. Questões sobre escalabilidade frequentemente surgem em entrevistas. Compreender quando migrar de Solid Cable para Redis demonstra maturidade técnica e capacidade de tomar decisões arquiteturais fundamentadas. ## Estratégias de Teste para Canais O Rails fornece helpers específicos para testar canais Action Cable, permitindo verificar inscrições, rejeições e broadcasts de forma isolada. ```ruby # test/channels/chat_channel_test.rb require "test_helper" class ChatChannelTest < ActionCable::Channel::TestCase test "subscribes to a valid room" do room = chat_rooms(:general) user = users(:alice) stub_connection current_user: user subscribe room_id: room.id assert subscription.confirmed? assert_has_stream_for room end test "rejects subscription for unauthorized user" do room = chat_rooms(:private) user = users(:outsider) stub_connection current_user: user subscribe room_id: room.id assert subscription.rejected? end test "broadcasts messages to room subscribers" do room = chat_rooms(:general) stub_connection current_user: users(:alice) subscribe room_id: room.id assert_broadcast_on(room, hash_including(body: "Hello")) do perform :receive, body: "Hello" end end end ``` O helper `stub_connection` simula uma conexão autenticada sem estabelecer um WebSocket real. Os métodos `subscribe` e `perform` interagem com o canal como um cliente faria. Assertions como `assert_has_stream_for` e `assert_broadcast_on` verificam comportamentos específicos de canais. Testes robustos para Action Cable demonstram profissionalismo e reduzem riscos de regressão em funcionalidades críticas de tempo real. ## Considerações de Segurança e Performance Implementações production-ready de Action Cable exigem atenção a aspectos além da funcionalidade básica. Rate limiting previne abusos por clientes mal-intencionados. Validação rigorosa de dados recebidos protege contra injeção de conteúdo malicioso. Timeout de conexões inativas libera recursos do servidor. A escolha entre Solid Cable e Redis impacta diretamente a capacidade de escala. Solid Cable atende bem aplicações com centenas de conexões, enquanto Redis suporta milhares com latência consistente. Monitoramento de métricas como número de conexões ativas e taxa de mensagens auxilia decisões de capacidade. ## Conclusão O Action Cable representa uma solução madura e bem integrada para comunicação em tempo real no ecossistema Rails. Dominar seus conceitos fundamentais, desde autenticação de conexões até estratégias de broadcasting e testes, prepara desenvolvedores para implementar funcionalidades sofisticadas e responder com confiança a questões técnicas em processos seletivos. A evolução do Rails 8 com Solid Cable demonstra o compromisso do framework com simplicidade operacional, enquanto mantém Redis como opção para cenários de alta demanda. Profissionais que compreendem essas nuances posicionam-se como candidatos diferenciados no mercado. Para consolidar o conhecimento apresentado neste artigo, a prática com questões específicas sobre o tema oferece preparação direcionada para entrevistas técnicas. [Praticar perguntas de entrevista sobre ActionCable e WebSockets](/pt/technologies/ruby-on-rails/interview-questions/action-cable-websockets) --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/pt/blog/ruby-on-rails/action-cable-websockets-complete-guide