## **FastAPI**'s `OAuth2PasswordBearer` { #fastapis-oauth2passwordbearer }

**FastAPI** provides several tools, at different levels of abstraction, to implement these security features.

In this example we are going to use **OAuth2**, with the **Password** flow, using a **Bearer** token. We do that using the `OAuth2PasswordBearer` class.

/// info

    return originalResponse.newBuilder()
        .header("Cache-Control", "max-age=60")
        .build();
  }
};
```

     */
    @Override
    public byte[] getSigningKey() throws SmbException {
        /*
         * The kerberos session key is not accessible via the JGSS API. IBM and
         * Oracle both implement a similar API to make an ExtendedGSSContext
         * available. That API is accessed via reflection to make this independent
         * of the runtime JRE
         */

import java.util.logging.Level;
import org.jspecify.annotations.Nullable;

/**
 * Base class for services that can implement {@link #startUp} and {@link #shutDown} but while in
 * the "running" state need to perform a periodic task. Subclasses can implement {@link #startUp},
 * {@link #shutDown} and also a {@link #runOneIteration} method that will be executed periodically.
 *

 * states it cannot ever leave them.
 *
 * <p>Implementors of this interface are strongly encouraged to extend one of the abstract classes
 * in this package which implement this interface and make the threading and state management
 * easier.
 *
 * @author Jesse Wilson
 * @author Luke Sandberg
 * @since 9.0 (in 1.0 as {@code com.google.common.base.Service})
 */

You will get an "Inactive user" error, like:

```JSON
{
  "detail": "Inactive user"
}
```

## Recap { #recap }

You now have the tools to implement a complete security system based on `username` and `password` for your API.

Using these tools, you can make the security system compatible with any database and with any user or data model.

unauthorized access to data or models, but also to prevent malicious users or
tenants sending graphs to execute under another tenant’s identity.

The isolation mechanisms are the responsibility of the users to design and
implement, and therefore security issues deriving from their absence are not
considered a vulnerability in TensorFlow.

### Resource allocation

A denial of service caused by one model could bring down the entire server, but

Pero cuando registras un manejador de excepciones, deberías registrarlo para el `HTTPException` de Starlette.

De esta manera, si alguna parte del código interno de Starlette, o una extensión o complemento de Starlette, lanza un `HTTPException` de Starlette, tu manejador podrá capturarlo y manejarlo.

        int cmd2 = (int) commandField.get(req2);

        assertEquals(cmd1, cmd2);
        assertEquals(SMB2_TREE_DISCONNECT, cmd1);
    }

    @Test
    @DisplayName("Should properly implement wire format protocol")
    void testWireFormatProtocol() {
        // Given
        Configuration mockConfig = mock(Configuration.class);
        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);

    class InterfaceImplementationTests {

        @Test
        @DisplayName("Should implement AllocInfo interface")
        void shouldImplementAllocInfo() {
            assertTrue(AllocInfo.class.isAssignableFrom(FileFsFullSizeInformation.class));
        }

        @Test
        @DisplayName("Should implement FileSystemInformation interface")
        void shouldImplementFileSystemInformation() {