Pusher — vad är det, realtidsplattform och integration i applikationer

Vad är Pusher?

Pusher — molntjänst för tvåvägs realtidskommunikation, grundad 2011. Den tillhandahåller färdig infrastruktur för att skicka och ta emot meddelanden i realtid utan att behöva hantera en egen WebSocket-server. Pusher används för att bygga chattar, live-notiser, samarbetsredigering och spellistningar.

Till skillnad från bibliotek som Socket.IO, som kräver driftsättning och underhåll av en egen server, fungerar Pusher enligt SaaS (Software as a Service)-modellen. Utvecklaren registrerar sig, får nycklar (app_id, key, secret) och använder Pushers REST API för att publicera händelser. Serverinfrastrukturen hanteras helt av Pusher-plattformen.

Enligt Pushers officiella blogg (2025), betjänar plattformen över 250 000 aktiva projekt världen över. Bland kända kunder finns GitHub (realtidsmeddelanden), Trello (synkronisering av anslagstavlor) och Intercom (supportchatt). Pusher stöder datacenter i USA, Europa och Asien för att minimera fördröjningar.

Pushers utvecklingshistoria

Pusher lanserades 2011 som en av de första värdtjänsterna för WebSocket. 2014 introducerade företaget Pusher Channels — den nuvarande arkitekturen med stöd för private och presence-kanaler. 2017 lades stöd för webhook för serverhändelser till. 2022 lanserade Pusher Pusher Beams — en push-notis-tjänst för mobila plattformar.

Pushers arkitektur skiljer sig från self-hostade lösningar genom att all prenumerationsbearbetning, anslutningshantering och händelseroutning sker på Pusher Cloud-sidan. Utvecklaren hanterar endast autentiseringen av private-kanaler via sin egen backend.

Hur Pusher fungerar

Pushers arkitektur är baserad på Publisher-Subscriber-modellen. Serverapplikationer publicerar händelser via Pushers REST API, och klientapplikationer tar emot dem via en permanent WebSocket-anslutning. Pusher fungerar som mellanhand mellan utgivare och prenumeranter.

När servern skickar en händelse via en POST-förfrågan till Pushers API, bestämmer plattformen målkanalen och sänder meddelandet till alla klienter som prenumererar på den kanalen. Klienter tar emot händelsen via den redan öppna WebSocket-anslutningen, vilket ger en latens på 50–100 ms beroende på geografisk plats.

Varje klient etablerar anslutning via Pusher Client SDK, som automatiskt väljer transport (WebSocket — prioritet, HTTP long-polling — fallback). SDK hanterar återanslutning, dataseriering och felhantering utan utvecklarens inblandning. Enligt Pushers tekniska dokumentation (2025), är återanslutningstiden vid nätverksavbrott mindre än 1 sekund.

Pusher-komponenter

Systemet består av tre komponenter: Pusher Server API (REST-slutpunkter för att publicera händelser), Pusher Client SDK (bibliotek för att prenumerera på händelser) och Pusher WebHook (servermeddelanden om anslutnings-/frånkopplingshändelser). Alla komponenter fungerar asynkront och oberoende.

Typer av Pusher-kanaler

Pusher Channels stöder tre typer av kanaler, var och en avsedd för olika användningsscenarier. Valet av kanaltyp bestämmer åtkomstnivån, autentiseringsmekanismen och tillgängliga funktioner.

Public-kanaler är tillgängliga för alla klienter utan autentisering och passar för sändningsdata. Private-kanaler kräver autentisering via utvecklarens server: klienten skickar en begäran till sin backend med socket_id och channel_name, servern signerar begäran med Pushers hemliga nyckel och returnerar en auth-token. Presence-kanaler överför dessutom användarinformation (user_id, user_info) och gör det möjligt att spåra vem som är online.

Enligt Pusher-dokumentation (2025), är det maximala antalet samtidigt anslutna klienter per kanal 10 000 för public och private-kanaler. För presence-kanaler är gränsen 10 000 användare per kanal med stöd för upp till 100 000 användare per applikation.

Pusher-händelser och triggers

Pushers händelsemodell är baserad på namngivna händelser som publiceras i en kanal. Varje händelse har ett namn (max 200 tecken), data i JSON-format och ett valfritt socket_id för att utesluta återsändning till händelseinitieraren.

Triggers — är HTTP POST-förfrågningar till Pushers API som publicerar en händelse i en kanal. Begäranformat: POST /apps/{app_id}/events med brödtext som innehåller channel, name och data. Pusher Server API stöder triggers från vilken servermiljö som helst via officiella bibliotek (PHP, Ruby, Python, Go, Java, Node.js).

Pusher stöder batch-triggers — publicering av en händelse i flera kanaler med en enda begäran. Detta är effektivare än sekventiella anrop och garanterar atomisk leverans. Enligt Pushers prestandatester (2024), tar en batch-trigger på 100 kanaler 30–50 ms, medan sekventiella anrop tar 2–5 sekunder.

Webhook-integration

Pusher WebHook gör det möjligt för din server att ta emot meddelanden om infrastrukturhändelser: klientanslutning, frånkoppling, feluppkomst. Webhook-begäranden signeras med HMAC-SHA256 för verifiering. Detta är avgörande för loggning, analys och statussynkronisering.

Hur man integrerar Pusher i ett projekt

Pusher-integration består av två delar: serversidan (publicering av händelser) och klientsidan (prenumeration på händelser). Låt oss titta på ett exempel i Node.js för serversidan och JavaScript för klientsidan. För att börja måste du skapa en applikation i Pusher-instrumentpanelen och få autentiseringsuppgifter.

Enligt Pusher-dokumentation (2025), inkluderar grundplanen (Sandbox) upp till 100 samtidiga anslutningar och 200 000 meddelanden per dag — tillräckligt för utveckling och testning. Produktionsplaner börjar från $49 per månad för 1000 anslutningar.

Serverkod: publicera en händelse

const Pusher = require('pusher');

const pusher = new Pusher({
    appId: 'YOUR_APP_ID',
    key: 'YOUR_KEY',
    secret: 'YOUR_SECRET',
    cluster: 'eu',
    useTLS: true
});

pusher.trigger('my-channel', 'my-event', {
    message: 'Hello from server',
    timestamp: Date.now()
}).then(() => {
    console.log('Händelse publicerad');
}).catch(console.error);

Klientkod: prenumerera på händelser

import Pusher from 'pusher-js';

const pusher = new Pusher('YOUR_KEY', {
    cluster: 'eu',
    forceTLS: true
});

const channel = pusher.subscribe('my-channel');

channel.bind('my-event', (data) => {
    console.log('Mottagen händelse:', data);
    displayNotification(data.message);
});

Pusher i mobilappar

Pusher tillhandahåller SDK för iOS (Swift) och Android (Java/Kotlin) som helt efterliknar JavaScript-klientens funktionalitet. Mobila SDK:er stöder samma kanaltyper, autentiseringsmekanism och händelsemodell. För React Native finns paketet pusher-js som fungerar via JavaScript-bryggan.

På mobila enheter hanterar Pusher SDK automatiskt växling mellan Wi-Fi och mobilt nätverk med hjälp av en återanslutningsmekanism med exponentiell fördröjning. Detta är särskilt viktigt för iOS-applikationer, där iOS kan tvinga stängning av WebSocket-anslutningar vid bakgrundsarbete.

Enligt Pushers tekniska blogg (2024), är den genomsnittliga trafikförbrukningen för en Pusher-anslutning 1–2 KB per minut vid frånvaro av aktiva händelser. Detta uppnås genom ett optimerat heartbeat-protokoll med 30 sekunders intervall. En medelstor applikation kan stödja upp till 1000 samtidiga Pusher-anslutningar utan betydande påverkan på batteriförbrukningen.

Pusher Beams för push-notiser

Pusher Beams — ytterligare tjänst för att skicka push-notiser till mobila enheter via APNs (iOS) och FCM (Android). Beams integreras med Pusher Channels: en händelse från en kanal kan automatiskt utlösa en push-notis om klienten är offline. Detta löser problemet med meddelandeleverans när appen är stängd.

Pusher-säkerhet och autentisering

Pusher-säkerhet är implementerad på flera nivåer. Varje begäran till Pusher API signeras med HMAC-SHA256 med app_secret. Detta garanterar att endast en auktoriserad server kan publicera händelser. Klient-SDK:er använder app_key för applikationsidentifiering, men för åtkomst till private och presence-kanaler krävs ytterligare autentisering.

Autentisering av private-kanaler sker i tre steg: klienten anropar pusher.subscribe('private-channel'), Pusher Client SDK skickar en HTTP-begäran till din backend-slutpunkt (/pusher/auth), servern kontrollerar användarens rättigheter och returnerar en auth-token signerad med den hemliga nyckeln. Pusher verifierar signaturen och tillåter prenumeration.

Det rekommenderas att använda TLS-anslutningar för alla begäranden (inställning useTLS: true i SDK). Pusher stöder också åtkomstbegränsning baserat på IP-adresser för serverförfrågningar till REST API. För företagsnivåer finns stöd för VPC (Virtual Private Cloud) och dedikerade kluster med isolerad infrastruktur.