Время простоя/поддержки жизни сессии

Часто возникают обстоятельства, когда необходимо защитить или минимизировать несанкционированное использование сессии, когда пользователь отходит от терминала во время нахождения в системе, путем уничтожения сессии после определенного периода простоя. Например, в банковских приложениях принято выводить пользователя из системы после 5 - 10 минут бездействия. Задавать время жизни куки здесь нецелесообразно, потому что клиент может манипулировать этим параметром, поэтому мы должны устанавливать срок действия на стороне сервера. Проще всего реализовать это через сбор мусора, который выполняется достаточно часто. cookie_lifetime должно быть установлено в относительно большое значение, а сбор мусора gc_maxlifetime будет настроен на уничтожение сессий при желаемом времени простоя.

Другой вариант - специально проверять, не истек ли срок действия сессии после её запуска. При необходимости сессия может быть уничтожена. Такой способ обработки позволяет интегрировать информацию об истечении сесии в пользовательский опыт, например, путем вывода сообщения.

Symfony записывает некоторые метаданные о каждой сессии, чтобы предоставить вам возможность тонкого контроля над настройками безопасности:

1
2

$session->getMetadataBag()->getCreated();
$session->getMetadataBag()->getLastUsed();

Оба метода возвращают временную отметку Unix (относительно сервера).

This metadata can be used to explicitly expire a session on access:

1
2
3
4
5

$session->start();
if (time() - $session->getMetadataBag()->getLastUsed() > $maxIdleTime) {
    $session->invalidate();
    throw new SessionExpired(); // перенаправление на страницу истекшей сессии
}

Также возможно сказать, какое cookie_lifetime было установлено для конкретного куки, прочитав метод getLifetime():

1

$session->getMetadataBag()->getLifetime();

Время истечения срока куки можно определеть путем добавления созданной временной метки и времени жизни.

Конфигурирование сбора мусора

Когда сессия открывается, PHP будет вызывать обработчик gc случайным образом в соответствии с вероятностью, заданной параметрами session.gc_probability / session.gc_divisor. Например, если они установлены в значения 5/100 соответственно, это будет означать вероятность 5%. Похожим образом, 3/4 будет означать вероятность вызова 3 из 4, то есть 75 %.

Если вызывается обработчик сборки мусора, PHP передаст значение, хранящееся в директиве php.ini session.gc_maxlifetime. В данном контексте это означает, что любая сохраненная сессия, которая была сохранена более чем gc_maxlifetime назад, должна быть удалена. Это позволяет исключать записи на основе времени простоя.

Однако некоторые операционные системы (например, Debian) сами обрабатывают сессии и устанавливают переменную session.gc_probability в значение 0, чтобы PHP перестал выполнять сборку мусора.
Поэтому Symfony теперь перезаписывает это значение как 1.

Если вы хотите использовать оригинальное значение, установленное в вашем php.ini, добавьте следующую конфигурацию:

1
2
3
4
5

# config/packages/framework.yaml
framework:
    session:
        # ...
        gc_probability: null

Вы можете сконфигурировать эти параметры, передав gc_probability, gc_divisor и gc_maxlifetime в виде массива в конструктор. и gc_maxlifetime в виде массива в конструктор
NativeSessionStorage или в метод
setOptions().

Храните сессии в базе данных ключ-значение (Redis)

В этом разделе предполагается, что у вас есть полностью рабочий сервер Redis, а также установлено и настроено расширение phpredis.

У вас есть два варианта использования Redis для хранения сессий:

Первый вариант, основанный на PHP, заключается в конфигурации обработчика сессий Redis непосредственно в файле сервера php.ini:

1
2
3

; php.ini
session.save_handler = redis
session.save_path = "tcp://192.168.0.178:6379?auth=REDIS_PASSWORD"

Второй вариант заключается в конфигурации сессий Redis в Symfony. Сначала определите сервис Symfony для подключения к серверу Redis:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# config/services.yaml
services:
    # ...
    Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler:
        arguments:
            - '@Redis'
            # вы можете по желанию передать массив опций. Единственными опциями являются 'prefix' и 'ttl',
            # которые определяют префикс для использования с ключами, чтобы избежать коллизий на сервере Redis
            # и время истечения срока действия для любой заданной записи (в секундах), по умолчанию - 'sf_s' и null:
            # - { 'prefix': 'my_prefix', 'ttl': 600 }

    Redis:
        # вы также можете использовать классы \RedisArray, \RedisCluster или \Predis\Client
        class: Redis
        calls:
            - connect:
                - '%env(REDIS_HOST)%'
                - '%env(int:REDIS_PORT)%'

            # раскомментируйте следующее, если ваш сервер Redis требует пароль
            # - auth:
            #     - '%env(REDIS_PASSWORD)%'

            # раскомментируйте следующее, если ваш сервер Redis требует пользователя и пароль (если пользователь не по умолчанию)
            # - auth:
            #     - ['%env(REDIS_USER)%','%env(REDIS_PASSWORD)%']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <!-- вы также можете использовать классы \RedisArray, \RedisCluster или \Predis\Client -->
        <service id="Redis" class="Redis">
            <call method="connect">
                <argument>%env(REDIS_HOST)%</argument>
                <argument>%env(int:REDIS_PORT)%</argument>
            </call>

            <!-- раскомментируйте следующее, если ваш сервер Redis требует пароль:
            <call method="auth">
                <argument>%env(REDIS_PASSWORD)%</argument>
            </call> -->

            <!-- раскомментируйте следующее, если ваш сервер Redis требует пользователя и пароль (если пользователь не по умолчанию):
            <call method="auth">
                <argument>%env(REDIS_USER)%</argument>
                <argument>%env(REDIS_PASSWORD)%</argument>
            </call> -->
        </service>

        <service id="Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler">
            <argument type="service" id="Redis"/>
            <!-- вы можете по желанию передать массив опций. Единственными опциями являются 'prefix' и 'ttl',
                 которые определяют префикс для использования с ключами, чтобы избежать коллизий на сервере Redis
                 и время истечения срока действия для любой заданной записи (в секундах), по умолчанию - 'sf_s' и null:
            <argument type="collection">
                <argument key="prefix">my_prefix</argument>
                <argument key="ttl">600</argument>
            </argument> -->
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// config/services.php
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler;

$container
    // вы также можете использовать классы \RedisArray, \RedisCluster или \Predis\Client
    ->register('Redis', \Redis::class)
    ->addMethodCall('connect', ['%env(REDIS_HOST)%', '%env(int:REDIS_PORT)%'])
    // раскомментируйте следующее, если ваш сервер Redis требует пароль:
    // ->addMethodCall('auth', ['%env(REDIS_PASSWORD)%'])
    // раскомментируйте следующее, если ваш сервер Redis требует пользователя и пароль (если пользователь не по умолчанию):
    // ->addMethodCall('auth', ['%env(REDIS_USER)%', '%env(REDIS_PASSWORD)%'])

    ->register(RedisSessionHandler::class)
    ->addArgument(
        new Reference('Redis'),
        // вы можете по желанию передать массив опций. Единственными опциями являются 'prefix' и 'ttl',
        // которые определяют префикс для использования с ключами, чтобы избежать коллизий на сервере Redis
        // и время истечения срока действия для любой заданной записи (в секундах), по умолчанию - 'sf_s' и null:
        // ['prefix' => 'my_prefix', 'ttl' => 600],
    )
;

Далее, используйте опцию конфигурации handler_id , чтобы указать Symfony использовать этот сервис как обработчик сессии:

1
2
3
4
5

# config/packages/framework.yaml
framework:
    # ...
    session:
        handler_id: Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<!-- config/packages/framework.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony
        https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <!-- ... -->
        <framework:session handler-id="Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler"/>
    </framework:config>
</container>

1
2
3
4
5
6
7
8
9
10

// config/packages/framework.php
use Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler;
use Symfony\Config\FrameworkConfig;

return static function (FrameworkConfig $framework): void {
    // ...
    $framework->session()
        ->handlerId(RedisSessionHandler::class)
    ;
};

Теперь Symfony будет использовать ваш сервер Redis для чтения и записи данных сессии. Основным недостатком этого решения является то, что Redis не выполняет блокировку сессий, поэтому при доступе к сессиям можно столкнуться с условиями гонки. Например, вы можете увидеть ошибку "Невалидный CSRF-токен", поскольку два запроса были сделаны параллельно и только первый из них сохранил CSRF-токен в сессии.

Храните сессии в реляционной базе данных (MariaDB, MySQL, PostgreSQL)

Symfony включает в себя PdoSessionHandler для хранения сессий в реляционных базах данных, таких как MariaDB, MySQL и PostgreSQL. Чтобы использовать его, сначала зарегистрируйте новый сервис-обработчик с учетными данными вашей базы данных:

1
2
3
4
5
6
7
8
9
10
11

# config/services.yaml
services:
    # ...

    Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler:
        arguments:
            - '%env(DATABASE_URL)%'

            # вы также можете использовать конфигурацию PDO, но это требует передачи двух аргументов
            # - 'mysql:dbname=mydatabase; host=myhost; port=myport'
            # - { db_username: myuser, db_password: mypassword }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<!-- config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <services>
        <service id="Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler">
            <argument>%env(DATABASE_URL)%</argument>

            <!-- вы также можете использовать конфигурацию PDO, но это требует передачи двух аргументов: -->
            <!-- <argument>mysql:dbname=mydatabase; host=myhost; port=myport</argument>
                <argument type="collection">
                    <argument key="db_username">myuser</argument>
                    <argument key="db_password">mypassword</argument>
                </argument> -->
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler;

return static function (ContainerConfigurator $container): void {
    $services = $container->services();

    $services->set(PdoSessionHandler::class)
        ->args([
            env('DATABASE_URL'),
            // вы также можете использовать конфигурацию PDO, но это требует передачи двух аргументов:
            // 'mysql:dbname=mydatabase; host=myhost; port=myport',
            // ['db_username' => 'myuser', 'db_password' => 'mypassword'],
        ])
    ;
};

Далее, используйте опцию конфигурации handler_id , чтобы сообщить Symfony использовать этот сервис как обработчик сессии:

1
2
3
4
5

# config/packages/framework.yaml
framework:
    session:
        # ...
        handler_id: Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!-- config/packages/framework.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony
        https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <!-- ... -->
        <framework:session
            handler-id="Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler"/>
    </framework:config>
</container>

1
2
3
4
5
6
7
8
9
10

// config/packages/framework.php
use Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler;
use Symfony\Config\FrameworkConfig;

return static function (FrameworkConfig $framework): void {
    // ...
    $framework->session()
        ->handlerId(PdoSessionHandler::class)
    ;
};

1
2
3
4
5
6
7
8

# config/services.yaml
services:
    # ...

    Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler:
        arguments:
            - '%env(DATABASE_URL)%'
            - { db_table: 'customer_session', db_id_col: 'guid' }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<!-- config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <service id="Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler">
            <argument>%env(DATABASE_URL)%</argument>
            <argument type="collection">
                <argument key="db_table">customer_session</argument>
                <argument key="db_id_col">guid</argument>
            </argument>
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler;

return static function (ContainerConfigurator $container): void {
    $services = $container->services();

    $services->set(PdoSessionHandler::class)
        ->args([
            env('DATABASE_URL'),
            ['db_table' => 'customer_session', 'db_id_col' => 'guid'],
        ])
    ;
};

1
2
3
4
5

try {
    $sessionHandlerService->createTable();
} catch (\PDOException $exception) {
    // таблица не могла быть создана по какой-то причине
}

1

$ php bin/console doctrine:migrations:generate

1

$ php bin/console doctrine:migrations:migrate

1
2
3
4
5
6
7

CREATE TABLE `sessions` (
    `sess_id` VARBINARY(128) NOT NULL PRIMARY KEY,
    `sess_data` BLOB NOT NULL,
    `sess_lifetime` INTEGER UNSIGNED NOT NULL,
    `sess_time` INTEGER UNSIGNED NOT NULL,
    INDEX `sessions_sess_lifetime_idx` (`sess_lifetime`)
) COLLATE utf8mb4_bin, ENGINE = InnoDB;

1
2
3
4
5
6
7

CREATE TABLE sessions (
    sess_id VARCHAR(128) NOT NULL PRIMARY KEY,
    sess_data BYTEA NOT NULL,
    sess_lifetime INTEGER NOT NULL,
    sess_time INTEGER NOT NULL
);
CREATE INDEX sessions_sess_lifetime_idx ON sessions (sess_lifetime);

1
2
3
4
5
6
7

CREATE TABLE sessions (
    sess_id VARCHAR(128) NOT NULL PRIMARY KEY,
    sess_data NVARCHAR(MAX) NOT NULL,
    sess_lifetime INTEGER NOT NULL,
    sess_time INTEGER NOT NULL,
    INDEX sessions_sess_lifetime_idx (sess_lifetime)
);

Храните сессии в базе данных NoSQL (MongoDB)

Symfony включает в себя MongoDbSessionHandler для хранения сессий в NoSQL базе данных MongoDB. Прежде всего, убедитесь, что в вашем приложении Symfony есть рабочее соединение с MongoDB, как описано в статье Конфигурация DoctrineMongoDBBundle.

Затем, зарегистрируйте новый сервис-обработчик для MongoDbSessionHandler и передайте его соединению MongoDB как аргумент, и обязателньые параметры:

database:

Имя базы данных

collection:

Имя коллекции

1
2
3
4
5
6
7
8

# config/services.yaml
services:
    # ...

    Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler:
        arguments:
            - '@doctrine_mongodb.odm.default_connection'
            - { database: '%env(MONGODB_DB)%', collection: 'sessions' }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<!-- config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <services>
        <service id="Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler">
            <argument type="service">doctrine_mongodb.odm.default_connection</argument>
            <argument type="collection">
                <argument key="database">%env('MONGODB_DB')%</argument>
                <argument key="collection">sessions</argument>
            </argument>
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler;

return static function (ContainerConfigurator $container): void {
    $services = $container->services();

    $services->set(MongoDbSessionHandler::class)
        ->args([
            service('doctrine_mongodb.odm.default_connection'),
            ['database' => '%env("MONGODB_DB")%', 'collection' => 'sessions']
        ])
    ;
};

Далее, используйте опцию конфигурации handler_id , чтобы указать Symfony использовать этот сервис как обработчик сессии:

1
2
3
4
5

# config/packages/framework.yaml
framework:
    session:
        # ...
        handler_id: Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!-- config/packages/framework.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony
        https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <!-- ... -->
        <framework:session
            handler-id="Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler"/>
    </framework:config>
</container>

1
2
3
4
5
6
7
8
9
10

// config/packages/framework.php
use Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler;
use Symfony\Config\FrameworkConfig;

return static function (FrameworkConfig $framework): void {
    // ...
    $framework->session()
        ->handlerId(MongoDbSessionHandler::class)
    ;
};

Вот и все! Теперь Symfony будет использовать ваш сервер MongoDB для чтения и записи данных сессии. Вам не нужно ничего делать для инициализации вашей коллекции сессий. Однако для повышения производительности сбора мусора может потребоваться добавить индекс. Запустите это из оболочки MongoDB:

1
2

use session_db
db.session.createIndex( { "expires_at": 1 }, { expireAfterSeconds: 0 } )

1
2
3
4
5
6
7
8
9
10
11
12

# config/services.yaml
services:
    # ...

    Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler:
        arguments:
            - '@doctrine_mongodb.odm.default_connection'
            -
                database: '%env(MONGODB_DB)%'
                collection: 'sessions'
                id_field: '_guid'
                expiry_field: 'eol'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<!-- config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <service id="Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler">
            <argument type="service">doctrine_mongodb.odm.default_connection</argument>
            <argument type="collection">
                <argument key="database">%env('MONGODB_DB')%</argument>
                <argument key="collection">sessions</argument>
                <argument key="id_field">_guid</argument>
                <argument key="expiry_field">eol</argument>
            </argument>
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// config/services.php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler;

return static function (ContainerConfigurator $container): void {
    $services = $container->services();

    $services->set(MongoDbSessionHandler::class)
        ->args([
            service('doctrine_mongodb.odm.default_connection'),
            [
                'database' => '%env('MONGODB_DB')%',
                'collection' => 'sessions'
                'id_field' => '_guid',
                'expiry_field' => 'eol',
            ],
        ])
    ;
};

Миграция между обработчиками сессий

Если в вашем приложении изменяется способ хранения сессий, используйте MigratingSessionHandler. для миграции между старым и новым обработчиком сохранения без потери данных сессии.

Вот рекомендуемый процесс миграции:

1. Переключитесь на обработчик миграции, при этом ваш новый обработчик будет работать только для записи. Старый обработчик ведет себя как обычно, а сессии записываются в новый:

   1

   $sessionStorage = new MigratingSessionHandler($oldSessionStorage, $newSessionStorage);

2. После окончания периода gc сессии проверьте правильность данных в новом обработчике.

3. Обновите обработчик миграции, чтобы использовать старый обработчик только для записи, чтобы теперь сессии считывались из нового обработчика. Этот шаг позволяет упростить откаты:

   1

   $sessionStorage = new MigratingSessionHandler($newSessionStorage, $oldSessionStorage);

4. Убедившись, что сессии в вашем приложении работают, переключитесь обработчика миграции на новый.

Конфигурация TTL сессии

Symfony по умолчанию будет использовать ini-настройку PHP session.gc_maxlifetime в качестве времени жизни сессии. Если вы храните сессии в базе данных, вы также можете настроить свой собственный TTL в конфигурации фреймворка или даже во время прогона.

1
2
3
4
5
6
7

# config/services.yaml
services:
    # ...
    Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler:
        arguments:
            - '@Redis'
            - { 'ttl': 600 }

1
2
3
4
5
6
7
8
9

<!-- config/services.xml -->
<services>
    <service id="Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler">
        <argument type="service" id="Redis"/>
        <argument type="collection">
            <argument key="ttl">600</argument>
        </argument>
    </service>
</services>

1
2
3
4
5
6
7
8
9

// config/services.php
use Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler;

$services
    ->set(RedisSessionHandler::class)
    ->args([
        service('Redis'),
        ['ttl' => 600],
    ]);

1
2
3
4
5
6
7
8
9
10
11
12
13

# config/services.yaml
services:
    # ...
    Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler:
        arguments:
            - '@Redis'
            - { 'ttl': !closure '@my.ttl.handler' }

    my.ttl.handler:
        class: Some\InvokableClass # какой-то класс с методом an __invoke()
        arguments:
            # Внедрите нужные вам зависимости, чтобы иметь возможность разрешить TTL для текущей сессии
            - '@security'

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<!-- config/services.xml -->
<services>
    <service id="Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler">
        <argument type="service" id="Redis"/>
        <argument type="collection">
            <argument key="ttl" type="closure" id="my.ttl.handler"/>
        </argument>
    </service>
    <!-- какой-то класс с методом an __invoke() -->
    <service id="my.ttl.handler" class="Some\InvokableClass">
        <!-- Внедрите нужные вам зависимости, чтобы иметь возможность разрешить TTL для текущей сессии -->
        <argument type="service" id="security"/>
    </service>
</services>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// config/services.php
use Symfony\Component\HttpFoundation\Session\Storage\Handler\RedisSessionHandler;

$services
    ->set(RedisSessionHandler::class)
    ->args([
        service('Redis'),
        ['ttl' => closure(service('my.ttl.handler'))],
    ]);

$services
    // какой-то класс с методом an __invoke()
    ->set('my.ttl.handler', 'Some\InvokableClass')
    // Внедрите нужные вам зависимости, чтобы иметь возможность разрешить TTL для текущей сессии
    ->args([service('security')]);

Создание LocaleSubscriber

Создайте нового подписчика событий . Обычно в качестве параметра маршрутизации используется _locale, чтобы указать локаль. Однако, вы можете определить правильную локаль любым способом:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// src/EventSubscriber/LocaleSubscriber.php
namespace App\EventSubscriber;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\KernelEvents;

class LocaleSubscriber implements EventSubscriberInterface
{
    public function __construct(
        private string $defaultLocale = 'en',
    ) {
    }

    public function onKernelRequest(RequestEvent $event): void
    {
        $request = $event->getRequest();
        if (!$request->hasPreviousSession()) {
            return;
        }

        // попробуйте увидеть, была ли локаль установлена как параметр маршрутизации _locale
        if ($locale = $request->attributes->get('_locale')) {
            $request->getSession()->set('_locale', $locale);
        } else {
            // если в этом запросе не было установлено четкой локали, используйте одну из сессии
            $request->setLocale($request->getSession()->get('_locale', $this->defaultLocale));
        }
    }

    public static function getSubscribedEvents(): array
    {
        return [
            // должно быть зарегистрировано ранее (т.е. с большим приоритетом, чем слушатель локали по умолчанию)
            KernelEvents::REQUEST => [['onKernelRequest', 20]],
        ];
    }
}

Если вы используете конфигурацию services.yaml по умолчанию , то все готово! Symfony автоматически узнает о подписчике событий и вызовет метод onKernelRequest. в каждом запросе.

Чтобы убедиться в его работоспособности, либо установите ключ _locale в сессии вручную (например, через какой-нибудь маршрут и контроллер "Change Locale"), либо создайте маршрут с
_locale по умолчанию .

1
2
3
4
5
6
7
8

# config/services.yaml
services:
    # ...

    App\EventSubscriber\LocaleSubscriber:
        arguments: ['%kernel.default_locale%']
        # раскомментируйте следующую строку, если вы не используете автоконфигурацию
        # tags: [kernel.event_subscriber]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!-- config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <service id="App\EventSubscriber\LocaleSubscriber">
            <argument>%kernel.default_locale%</argument>

            <!-- раскомментируйте следующую строку, если вы не используете автоконфигурацию -->
            <!-- <tag name="kernel.event_subscriber"/> -->
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8

// config/services.php
use App\EventSubscriber\LocaleSubscriber;

$container->register(LocaleSubscriber::class)
    ->addArgument('%kernel.default_locale%')
    // раскомментируйте следующую строку, если вы не используете автоконфигурацию
    // ->addTag('kernel.event_subscriber')
;

Теперь отпразднуйте это событие, изменив локаль пользователя и убедившись, что она сохраняется на протяжении всего запроса.

Помните, чтобы получить локаль пользователя, всегда используйте метод Request::getLocale:

1
2
3
4
5
6
7

// из контроллера...
use Symfony\Component\HttpFoundation\Request;

public function index(Request $request): void
{
    $locale = $request->getLocale();
}

Установка локали, основываясь на предпочтениях пользователя

Возможно, вы захотите усовершенствовать эту технику еще больше и определить локаль на основе сущности пользователя, вошедшего в систему. Однако, поскольку LocaleSubscriber вызывается перед FirewallListener, который отвечает за обработку аутентификации и установку токена пользователя в TokenStorage, вы не имеете доступа к пользователю, который вошел в систему.

Предположим, что у вас есть свойство locale в вашей сущности User и вы хотите использовать его в качестве локали для заданного пользователя. Для этого можно подключиться к процессу входа в систему и обновить сессию пользователя с этим значением локали до того, как он будет перенаправлен на первую страницу.

Для этого необходимо создать подписчика события в событии security.interactive_login.:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// src/EventSubscriber/UserLocaleSubscriber.php
namespace App\EventSubscriber;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\Security\Http\Event\LoginSuccessEvent;

/**
 * Сохраняет локаль пользователя в сессии посе входа в систему.
 * Это может быть использовано позже LocaleSubscriber.
 */
class UserLocaleSubscriber implements EventSubscriberInterface
{
    public function __construct(
        private RequestStack $requestStack,
    ) {
    }

    public function onLoginSuccess(LoginSuccessEvent $event): void
    {
        $user = $event->getUser();

        if (null !== $user->getLocale()) {
            $this->requestStack->getSession()->set('_locale', $user->getLocale());
        }
    }

    public static function getSubscribedEvents(): array
    {
        return [
            LoginSuccessEvent::class => 'onLoginSuccess',
        ];
    }
}

Шифрование данных сессии

Если вы хотите зашифровать данные сессии, вы можете использовать прокси для шифрования и расшифровки сессии по необходимости. В следующем примере используется библиотека php-encryption, но вы можете адаптировать его к любой другой библиотеке, которую вы используете:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// src/Session/EncryptedSessionProxy.php
namespace App\Session;

use Defuse\Crypto\Crypto;
use Defuse\Crypto\Key;
use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy;

class EncryptedSessionProxy extends SessionHandlerProxy
{
    public function __construct(
        private \SessionHandlerInterface $handler,
        private Key $key
    ) {
        parent::__construct($handler);
    }

    public function read($id): string
    {
        $data = parent::read($id);

        return Crypto::decrypt($data, $this->key);
    }

    public function write($id, $data): string
    {
        $data = Crypto::encrypt($data, $this->key);

        return parent::write($id, $data);
    }
}

Еще одна возможность зашифровать данные сессии - декорировать сервис session.marshaller, который указывает на MarshallingSessionHandler. Вы можете декорировать этот обработчик маршаллером, который использует шифрование, например, SodiumMarshaller.

Сначала вам нужно сгенерировать безопасный ключ и добавить его в ваше хранилище секретов как SESSION_DECRYPTION_FILE:

1

$ php -r 'echo base64_encode(sodium_crypto_box_keypair());'

Затем зарегистрируйте сервис SodiumMarshaller, используя этот ключ:

1
2
3
4
5
6
7
8
9

# config/services.yaml
services:

    # ...
    Symfony\Component\Cache\Marshaller\SodiumMarshaller:
        decorates: 'session.marshaller'
        arguments:
            - ['%env(file:resolve:SESSION_DECRYPTION_FILE)%']
            - '@.inner'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!-- config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd"
>
    <services>
        <service id="Symfony\Component\Cache\Marshaller\SodiumMarshaller" decorates="session.marshaller">
            <argument type="collection">
                <argument>env(file:resolve:SESSION_DECRYPTION_FILE)</argument>
            </argument>
            <argument type="service" id=".inner"/>
        </service>
    </services>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// config/services.php
use Symfony\Component\Cache\Marshaller\SodiumMarshaller;
use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
// ...

return function(ContainerConfigurator $container) {
    $services = $container->services();

    // ...

    $services->set(SodiumMarshaller::class)
        ->decorate('session.marshaller')
        ->args([
            [env('file:resolve:SESSION_DECRYPTION_FILE')],
            service('.inner'),
        ]);
};

Гостевые сессии только для чтения

Существуют некоторые приложения, в которых сессия необходима для гостевых пользователей, но где нет особой необходимости сохранять сессию. В этом случае можно перехватить сессию до того как она будет записана:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// src/Session/ReadOnlySessionProxy.php
namespace App\Session;

use App\Entity\User;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy;

class ReadOnlySessionProxy extends SessionHandlerProxy
{
    public function __construct(
        private \SessionHandlerInterface $handler,
        private Security $security
    ) {
        parent::__construct($handler);
    }

    public function write($id, $data): string
    {
        if ($this->getUser() && $this->getUser()->isGuest()) {
            return;
        }

        return parent::write($id, $data);
    }

    private function getUser(): ?User
    {
        $user = $this->security->getUser();
        if (is_object($user)) {
            return $user;
        }

        return null;
    }
}