Wie kann eine Authentifizierung für einen Webdienst mithilfe des Silex-Frameworks bereitgestellt werden?

Silex ist ein leichtes Web-Framework, das auf der PHP-Sprache basiert. Es bietet eine Reihe von Komponenten und Tools, um die Webentwicklung einfacher und effizienter zu machen. Unter diesen ist die Authentifizierung eine der wichtigen Verbindungen beim Aufbau von Webdiensten. Sie kann sicherstellen, dass nur autorisierte Benutzer auf den Dienst zugreifen können. Im Silex-Framework erfordert die Verwendung der Authentifizierung einige Konfigurations- und Codeimplementierungen. In diesem Artikel stellen wir die Verwendung der Authentifizierung im Silex-Framework vor.

1. Grundidee

Im Silex-Framework kann die Authentifizierung durch Verwendung der Symfony Security-Komponente erreicht werden. Der grundlegende Prozess ist wie folgt:

1. Rufen Sie die vom Benutzer bereitgestellten Identitätsinformationen ab, z. B. Benutzername und Passwort.
2. Verwenden Sie die erhaltenen Identitätsinformationen zur Identitätsauthentifizierung. Wenn die Authentifizierung erfolgreich ist, wird ein Authentifizierungszertifikat generiert.
3. Verwenden Sie Authentifizierungsdaten zur Zugriffskontrolle bei nachfolgenden Anfragen.

2. Installieren Sie die erforderlichen Komponenten

Um die Symfony Security-Komponente zu verwenden, müssen Sie die erforderlichen Komponenten im Silex-Framework installieren. Andere abhängige Komponenten können einfach über Composer installiert werden. Erstellen Sie eine Composer.json-Datei im Stammverzeichnis des Projekts und fügen Sie den folgenden Inhalt hinzu:

{
    "require": {
        "silex/silex": "~2.0",
        "symfony/security": "^4.3"
    },
    "autoload": {
        "psr-4": { "": "src/" }
    }
}

Führen Sie dann den Composer-Installationsbefehl aus, um abhängige Komponenten zu installieren.

3. Authentifizierungsinformationen konfigurieren

Um Authentifizierungsinformationen zu konfigurieren, müssen Sie einen Sicherheitsdienst im Silex-Framework definieren und einen Identitätsanbieter und einen Benutzeranbieter für diesen Sicherheitsdienst angeben. Der Identitätsanbieter ist für die Überprüfung der Identitätsinformationen verantwortlich, und der Benutzeranbieter ist für die Bereitstellung von Benutzerdetails verantwortlich. Bei einfachen Webanwendungen können diese beiden Dienste dieselbe Implementierung verwenden. Fügen Sie app.php den folgenden Code hinzu:

use SymfonyComponentSecurityCoreUserInMemoryUserProvider;
use SymfonyComponentSecurityCoreUserUser;
use SymfonyComponentSecurityCoreUserUserProviderInterface;

$app->register(new SilexProviderSecurityServiceProvider());

$app['security.firewalls'] = array(
    'secured' => array(
        'pattern' => '^/secured',
        'http' => true,
        'users' => function() use($app){
            return new InMemoryUserProvider(
                array(
                    'admin' => array('ROLE_USER', 'password')
                )
            );
        }
    )
);

$app['security.access_rules'] = array(
    array('^/secured', 'ROLE_USER')
);

$app['security.role_hierarchy'] = array(
    'ROLE_ADMIN' => array('ROLE_USER')
);

$app['security.user_provider'] = function($app) {
    return new UserProvider($app['db']);
};

$app['security.encoder.bcrypt'] = $app->share(function($app) {
    return new BCryptPasswordEncoder($app['security.encoder.bcrypt.cost']);
});

$app['security.authentication_listener.factory.form'] = $app->protect(function ($name, $options) use ($app) {
    $app['security.authentication_provider.'.$name.'.form'] = function () use ($app) {
        return new FormAuthenticationProvider(
            $app['security.user_provider'],
            $app['security.encoder_factory']
        );
    };
 
    $app['security.authentication_listener.'.$name.'.form'] = function () use ($app, $name, $options) {
        return new FormAuthenticationListener(
            $app['security'],
            $app['security.authentication_manager'],
            $name,
            $options,
            new UsernamePasswordFormAuthenticationEntryPoint(
                $app,
                $app['security.http_utils'],
                $name
            ),
            $app['logger'],
            $app['dispatcher'],
            $app['security.authentication.session_strategy']
        );
    };
 
    return array(
        'security.authentication_provider.'.$name.'.form',
        'security.authentication_listener.'.$name.'.form',
        null,
        'pre_auth'
    );
});

4. Erstellen Sie einen Benutzeranbieter (UserProvider)

Das Erstellen eines Benutzeranbieters erfordert die Implementierung der SymfonyComponentSecurityCoreUserUserProviderInterface-Schnittstelle, die einige Methoden zum Abrufen von Benutzerinformationen enthält. Erstellen Sie einen UserProvider in app.php und fügen Sie den folgenden Code hinzu:

use SymfonyComponentSecurityCoreUserUserProviderInterface;
use SymfonyComponentSecurityCoreUserUserInterface;
use SymfonyComponentSecurityCoreExceptionUnsupportedUserException;

class UserProvider implements UserProviderInterface
{
    private $db;

    public function __construct(Connection $db)
    {
        $this->db = $db;
    }

    public function loadUserByUsername($username)
    {
        $stmt = $this->db->executeQuery('SELECT * FROM users WHERE username = ?', array(strtolower($username)));

        if (!$user = $stmt->fetch()) {
            throw new UsernameNotFoundException(sprintf('Username "%s" does not exist.', $username));
        }

        $rolesStmt = $this->db->executeQuery('SELECT roles.role FROM user_roles JOIN roles ON user_roles.role_id = roles.id WHERE user_id = ?', array($user['id']));
        $roles = array();
        while ($role = $rolesStmt->fetch(PDO::FETCH_ASSOC)) {
            $roles[] = $role['role'];
        }

        return new User($user['username'], $user['password'], explode(',', $user['roles']), true, true, true, true);
    }

    public function refreshUser(UserInterface $user)
    {
        if (!$user instanceof User) {
            throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', get_class($user)));
        }

        return $user;
    }

    public function supportsClass($class)
    {
        return $class === 'SymfonyComponentSecurityCoreUserUser';
    }
}

Im obigen Code wird die Methode „loadUserByUsername“ verwendet, um Benutzerinformationen basierend auf dem Benutzernamen und den Rollen (Rollen) des Benutzers „refreshUser“ und „supportsClass“ abzufragen Methoden sind für die Implementierung der Schnittstelle erforderlich.

5. Erstellen Sie einen Controller

Das Erstellen eines Controllers im Silex-Framework erfordert die Definition einer privaten URL, die Benutzer zur Anmeldeseite zur Identitätsauthentifizierung führt. Bei erfolgreicher Authentifizierung wird der Benutzer aktiv zur ursprünglich angeforderten URL weitergeleitet. Wenn die Authentifizierung fehlschlägt, wird eine Fehlermeldung ausgegeben und die Anmeldeseite zur erneuten Authentifizierung angezeigt.

Fügen Sie den folgenden Code in app.php hinzu:

$app->match('/login', function(Request $request) use ($app){
        $username = $request->request->get('_username');
        $password = $request->request->get('_password');

        $user = $app['security.user_provider']->loadUserByUsername($username);

        if (!$app['security.encoder.bcrypt']->isPasswordValid($user->getPassword(), $password, $user->getSalt())) {
            throw new Exception('Bad credentials');
        } else {
            $token = new UsernamePasswordToken($user, null, 'secured', $user->getRoles());
            $app['security.token_storage']->setToken($token);
            $request->getSession()->set('_security_secured', serialize($token));
            return $app->redirect($request->headers->get('referer'));
        }
})->bind('login');

$app->match('/secured', function() use ($app){
        if (!$app['security.authorization_checker']->isGranted('ROLE_USER')){
            return $app->redirect('/login');
        }
 
        return 'Welcome ' . $app['security.token_storage']->getToken()->getUsername();
})->bind('secured');

Im obigen Code ist die /login-Route eine private URL, die es Benutzern ermöglicht, Benutzernamen- und Passwortinformationen zur Authentifizierung zu übermitteln, und die /secured-Route ist eine Route mit eingeschränktem Zugriff Zugriffsrechte. Wenn der Benutzer ohne Authentifizierung auf die Route /secured zugreift, wird er zur Anmeldeseite weitergeleitet.

6. Zusammenfassung

Durch die oben genannten Schritte haben wir die Funktion zur Authentifizierung der Benutzeridentität im Silex-Framework implementiert. In diesem Prozess haben wir die Symfony-Sicherheitskomponente verwendet, um Authentifizierungs- und Benutzeranbieterfunktionen zu implementieren. Gleichzeitig müssen Konfigurationsinformationen, Benutzeranbieter und Controller konfiguriert werden, um ein vollständiges Authentifizierungssystem zu implementieren. Ich hoffe, durch die obige Einführung einen Hinweis auf Entwickler zu geben, die Authentifizierungsfunktionen im Silex-Framework implementieren müssen.

Das obige ist der detaillierte Inhalt vonWie kann eine Authentifizierung für einen Webdienst mithilfe des Silex-Frameworks bereitgestellt werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!