- author: Raf Rasenberg
    author_link: https://rafrasenberg.com/about/
    link: https://rafrasenberg.com/fastapi-lambda/
    title: 'FastAPI lambda container: serverless simplified'
  - author: Teresa N. Fontanella De Santis
    author_link: https://dev.to/
    link: https://dev.to/teresafds/authorization-on-fastapi-with-casbin-41og
    title: Authorization on FastAPI with Casbin

    The correct place is:

    * In the key `content`, that has as value another JSON object (`dict`) that contains:
        * A key with the media type, e.g. `application/json`, that contains as value another JSON object, that contains:
            * A key `schema`, that has as the value the JSON Schema from the model, here's the correct place.

    The examples here use `.dict()` for compatibility with Pydantic v1, but you should use `.model_dump()` instead if you can use Pydantic v2.

!!! tip
    The SQLAlchemy model for `User` contains a `hashed_password` that should contain a secure hashed version of the password.

    But as what the API client provides is the original password, you need to extract it and generate the hashed password in your application.

* **Cloud-Dienste**, welche das für Sie erledigen

**FastAPI** will use that *temporal* response to extract the cookies (also headers and status code), and will put them in the final response that contains the value you returned, filtered by any `response_model`.

You can also declare the `Response` parameter in dependencies, and set cookies (and headers) in them.

## Return a `Response` directly

                    corresponding JSON.
                * Filtering: the JSON sent to the client will only contain the data
                    (fields) defined in the `response_model`. If you returned an object
                    that contains an attribute `password` but the `response_model` does
                    not include that field, the JSON sent to the client would not have

You can override these exception handlers with your own.

### Override request validation exceptions

When a request contains invalid data, **FastAPI** internally raises a `RequestValidationError`.

And it also includes a default exception handler for it.

Then you can write a template at `templates/item.html` with, for example:

```jinja hl_lines="7"
{!../../../docs_src/templates/templates/item.html!}
```

### Template Context Values

In the HTML that contains:

{% raw %}

```jinja
Item ID: {{ id }}
```

{% endraw %}

...it will show the `id` taken from the "context" `dict` you passed:

```Python
{"id": id}
```

When the **container** is started and running (started from a **container image**) it could create or change files, environment variables, etc. Those changes will exist only in that container, but would not persist in the underlying container image (would not be saved to disk).

Wenn Sie in hier **mehrere Container** hätten, würde Prometheus beim **Lesen der Metriken** standardmäßig jedes Mal diejenigen für **einen einzelnen Container** abrufen (für den Container, der den spezifischen Request verarbeitet hat), anstatt die **akkumulierten Metriken** für alle replizierten Container abzurufen.