---
title: "Synchronizácia Laravel aplikácií cez Redis | Roundly"
description: "Prepojte dve Laravel aplikácie cez jednu Redis inštanciu a synchronizujte dáta queue jobmi — konfigurácia pripojenia, job triedy aj worker."
url: https://roundly-consulting.com/sk/blog/synchronizacia-laravel-aplikacii-s-redisom
language: sk
---

[Všetky články](https://roundly-consulting.com/sk/blog.md)

Laravel· 6\. júna 2023· Aktualizované 12\. júna 2026

# Synchronizácia Laravel aplikácií cez Redis

![Synchronizácia Laravel aplikácií cez Redis — Roundly Consulting](https://roundly-consulting.com/images/blog/laravel-application-synchronization-with-redis.webp)

Keď si dve Laravel aplikácie potrebujú vymieňať dáta, prvý reflex býva postaviť medzi nimi HTTP API. Existuje však ľahšia cesta: nasmerovať obe aplikácie na jednu zdieľanú Redis inštanciu a nechať správy prenášať queue systém Laravelu. Jedna strana job odošle, druhá ho spracuje — retry, backoff a monitoring dostanete s queue workerom zadarmo.

V tomto návode nakonfigurujeme samostatné Redis pripojenie v oboch aplikáciách, definujeme zhodnú job triedu na každej strane a spustíme worker, ktorý synchronizačné joby spracúva. Vlastný prefix kľúčov drží zdieľanú frontu oddelenú od predvolených front oboch aplikácií.

## 1\. Konfigurácia Redis pripojenia

V oboch aplikáciách otvorte config/database.php a do poľa redis pridajte pripojenie s názvom sync. Dôležitá je voľba prefix: Laravel predvolene prefixuje Redis kľúče podľa aplikácie, takže dve aplikácie by aj na rovnakom serveri čítali a zapisovali rôzne kľúče. Rovnaký explicitný prefix na oboch stranách zabezpečí, že vidia tú istú frontu.

```php
'connections' => [
    // Other connections...

    'sync' => [
        'url' => env('SYNC_REDIS_URL'),
        'host' => env('SYNC_REDIS_HOST', '127.0.0.1'),
        'port' => env('SYNC_REDIS_PORT', '6379'),
        'password' => env('SYNC_REDIS_PASSWORD', null),
        'database' => env('SYNC_REDIS_DB', '1'),
        'options' => [
            'prefix' => env('SYNC_REDIS_PREFIX', 'app_sync_')
        ],
    ],
],
```

Hodnoty SYNC\_REDIS\_HOST, SYNC\_REDIS\_PORT a SYNC\_REDIS\_PASSWORD nasmerujte na Redis server, ktorý obe aplikácie zdieľajú.

## 2\. Synchronizačný job

### Zdrojová aplikácia

Zdrojová aplikácia joby iba odosiela — nikdy ich nespúšťa. Jej job trieda preto potrebuje správny názov, rovnaké verejné properties ako trieda v cieľovej aplikácii a pripojenie sync. Metóda handle ostáva prázdna:

```php
class SynchronizeItem implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function __construct(public array $data)
    {
        $this->onConnection('sync');
    }

    public function handle(): void
    {
        // Iba definícia — spracovanie prebieha v cieľovej aplikácii.
    }
}
```

### Cieľová aplikácia

Cieľová aplikácia definuje tú istú triedu — rovnaký názov, rovnaký konštruktor — a v metóde handle payload skutočne spracuje:

```php
class SynchronizeItem implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function __construct(public array $data)
    {
        $this->onConnection('sync');
    }

    public function handle(): void
    {
        // Payload smerujeme podľa typu — napr. vyvoláme doménový event.
        match($this->data['type']) {
            SynchronizationType::Transaction->value => $this->processTransaction(),
        };
    }

    protected function processTransaction(): void
    {
        TransactionSynchronized::dispatch($this->data);
    }
}
```

Názvy tried a tvar properties sa musia zhodovať presne — queue serializuje job podľa názvu triedy, takže nesúlad sa prejaví ako failed job na cieľovej strane.

## 3\. Odoslanie jobu

Zo zdrojovej aplikácie job odošlete ako každý iný Laravel job. Namiesto lokálnej fronty skončí na zdieľanej Redis fronte:

```php
SynchronizeItem::dispatch([
    'type' => 'Transaction',
    'item' => [
        'currency' => 'EUR',
        'amountInCents' => 150_000,
    ],
]);
```

## 4\. Queue worker

Na cieľovej strane zaregistrujte queue pripojenie sync v config/queue.php, aby ho worker mohol počúvať:

```php
'connections' => [
    // Other connections...

    'sync' => [
        'driver' => 'redis',
        'connection' => 'sync', // Pripojenie definované v database.php
        'queue' => env('SYNC_REDIS_QUEUE', 'default'),
        'retry_after' => 90,
        'block_for' => null,
        'after_commit' => false,
    ],
]
```

Potom spustite worker (v produkcii pod Supervisorom alebo systemd):

```bash
php artisan queue:work sync
```

Worker počúva frontu default na pripojení sync a spracuje každý job, ktorý zdrojová aplikácia odošle.

## Záver

Dve Laravel aplikácie si teraz vymieňajú dáta cez jednu Redis inštanciu len pomocou queue primitív, ktoré Laravel už obsahuje: zdieľané pripojenie, zhodná job trieda na oboch stranách a worker. Vlastný prefix kľúčov drží synchronizačnú frontu oddelenú od vlastných jobov aplikácií a spracovanie zlyhaných jobov, retry aj monitoring fungujú ako pri bežných frontách.

Návrh spoľahlivých integrácií medzi systémami — fronty, API, webhooky, synchronizácie — je každodennou súčasťou našich [API a integračných služieb](https://roundly-consulting.com/sk/sluzby/api-systemy.md). Ak si vaše aplikácie stále vymieňajú dáta cez CSV exporty, napíšte nám.

## Chcete, aby to fungovalo aj u vás?

Napíšte nám, čo chcete zautomatizovať alebo postaviť — do 48 hodín odpovieme s konkrétnym návrhom.

[Ponuka do 48 hodín](https://roundly-consulting.com/sk/kontakt.md) [Pozrite si možnosti použitia](https://roundly-consulting.com/sk/moznosti-pouzitia.md)