Nais

https://docs.nais.io
Admin
Nais is a developer platform that simplifies application deployment, data persistence,...
Tokens:401,277
Snippets:3,782
Trust Score:7.7
Update:7 months ago
Show doc for...
Tokens:
Raw
### Configure Startup Probe

Source: https://docs.nais.io/workloads/application/reference/application-example

Defines the configuration for the startup probe, which checks if an application has successfully started. Includes parameters like path, port, and timing thresholds.

```yaml
startup:
  failureThreshold: 10
  initialDelay: 20
  path: /started
  periodSeconds: 5
  port: 8080
  timeout: 1
```

--------------------------------

### Install naisdevice on Ubuntu using APT

Source: https://docs.nais.io/operate/naisdevice/how-to/install/index.html

Installs naisdevice on Ubuntu by first installing curl, then adding the nais PPA repository by downloading and adding the signing key and configuring the sources list, and finally updating the package list and installing naisdevice. Requires administrator privileges.

```shell
sudo apt install curl
NAIS_GPG_KEY="/etc/apt/keyrings/nav_nais_gar.asc"
curl -sfSL "https://europe-north1-apt.pkg.dev/doc/repo-signing-key.gpg" | sudo dd of="$NAIS_GPG_KEY"
echo "deb [arch=amd64 signed-by=$NAIS_GPG_KEY] https://europe-north1-apt.pkg.dev/projects/nais-io nais-ppa main" | sudo tee /etc/apt/sources.list.d/nav_nais_gar.list
sudo apt update
sudo apt install naisdevice
```

--------------------------------

### Setup PostgreSQL Database Migration with NAIS CLI

Source: https://docs.nais.io/persistence/cloudsql/how-to/migrate-to-new-instance/index.html?q=

Initiates the migration process for a PostgreSQL database using the NAIS CLI. This command sets up replication and prepares the new SQLInstance for promotion. Ensure you have the latest NAIS CLI installed and provide the team, environment, application name, and the new SQLInstance name as arguments.

```bash
nais postgres migrate setup --team <team> --environment <environment> <appname> <new-sql-instance-name>
```

--------------------------------

### Get Started with Grafana Loki (NAIS)

Source: https://docs.nais.io/tags/index.html?q=

Guides users on how to start using Grafana Loki for log aggregation within the NAIS platform. It covers basic setup and integration.

```text
To get started with Grafana Loki in NAIS, ensure your application is configured to send logs to the Loki endpoint. You can then use Grafana to query and visualize these logs. Refer to the NAIS documentation for specific configuration details.
```

--------------------------------

### Enable Auto-Instrumentation for Other Runtimes (SDK Mode)

Source: https://docs.nais.io/observability/how-to/auto-instrumentation/index.html?q=

Enables OpenTelemetry configuration for applications with unsupported runtimes or for manual instrumentation. This mode sets up the configuration but does not inject the agent.

```yaml
spec:
  observability:
    autoInstrumentation:
      enabled: true
      runtime: sdk

```

--------------------------------

### Valkey Configuration Example

Source: https://docs.nais.io/persistence/valkey/reference/index.html?q=

Example of how to configure Valkey instances within a Kubernetes manifest. It specifies the instance name and the desired access mode.

```yaml
spec:
  valkey:
    - instance: <ValkeyInstanceName>
      access: readwrite | read | write | admin
```

--------------------------------

### Ingress Configuration Example

Source: https://docs.nais.io/workloads/application/explanations/expose

Illustrates how to configure ingresses in a Kubernetes manifest to expose an application to external users or services. It shows a basic ingress URL and examples with multiple domains and paths.

```yaml
spec:
  ingresses:
    - https://myapplication.example.com
```

```yaml
spec:
  ingresses:
    - https://myapplication.example.com
    - https://myapplication2.example.com
    - https://myapplication.internal.example.com
```

```yaml
spec:
  ingresses:
    - https://myapplication.example.com/some-path
```

--------------------------------

### Enable Auto-Instrumentation for Java/Kotlin

Source: https://docs.nais.io/observability/how-to/auto-instrumentation/index.html?q=

Enables auto-instrumentation for Java and Kotlin applications. This configuration requires the OpenTelemetry Agent to be set up with the 'java' runtime.

```yaml
spec:
  observability:
    autoInstrumentation:
      enabled: true
      runtime: java

```

--------------------------------

### Install naisdevice on Ubuntu using APT

Source: https://docs.nais.io/operate/naisdevice/how-to/install/index.html?q=

Installs naisdevice on Ubuntu by adding the nais PPA repository and then installing the naisdevice package using apt. Requires curl and sudo privileges for package management.

```shell
NAIS_GPG_KEY="/etc/apt/keyrings/nav_nais_gar.asc"
curl -sfSL "https://europe-north1-apt.pkg.dev/doc/repo-signing-key.gpg" | sudo dd of="$NAIS_GPG_KEY"
echo "deb [arch=amd64 signed-by=$NAIS_GPG_KEY] https://europe-north1-apt.pkg.dev/projects/nais-io nais-ppa main" | sudo tee /etc/apt/sources.list.d/nav_nais_gar.list
sudo apt update
sudo apt install naisdevice
```

--------------------------------

### Usage Example for Application Redirects

Source: https://docs.nais.io/workloads/application/how-to/redirect

An example demonstrating how to configure redirects in the `.nais/app.yaml` file. It shows specific HTTP URLs for both the source and target of the redirection.

```yaml
apiVersion: nais.io/v1alpha1
kind: Application
spec:
  ingress:
    - http://example-new.nais.io
  redirects:
    - from: "http://example-old.nais.io"
      to: "http://example-new.nais.io"
```

--------------------------------

### Postgres Cluster Resources Configuration Example (YAML)

Source: https://docs.nais.io/persistence/postgresql/reference/index.html?q=

Example of configuring CPU, memory, and disk size for a Postgres cluster in YAML.

```yaml
spec:
  cluster:
    resources:
      cpu: 100m          # CPU in milli-cores
      memory: 2G         # Memory in GiB
      diskSize: 1Gi      # Disk size in GiB

```

--------------------------------

### Postgres Version Configuration Example (YAML)

Source: https://docs.nais.io/persistence/postgresql/reference/index.html?q=

Example of setting the major Postgres version in the resource specification.

```yaml
spec: 
  cluster:
    majorVersion: "17"

```

--------------------------------

### Manual Installation of nais-cli on Windows

Source: https://docs.nais.io/operate/cli/how-to/install/index.html?q=

Manually installs the nais-cli on Windows by downloading the archive and unpacking it to a directory included in the system's PATH environment variable.

```bash
# Download the archive for windows from nais/cli and unpack the tool to a directory on your $PATH.
```

--------------------------------

### Postgres Configuration Example (YAML)

Source: https://docs.nais.io/persistence/postgresql/reference/index.html

Example YAML configuration for a Postgres resource in NAIS, demonstrating how to specify extensions, database collation, cluster resources, and the major version.

```yaml
kind: Postgres
metadata:
  name: my-postgres-cluster
spec:
  cluster:
    ...
  database:
    extensions:
    - name: postgis
    - name: pgcrypto
    collation: nb_NO
    resources:
      cpu: 100m          # CPU in milli-cores
      memory: 2G         # Memory in GiB
      diskSize: 1Gi      # Disk size in GiB
    majorVersion: "17"
```

--------------------------------

### Install naisdevice on Windows using Scoop

Source: https://docs.nais.io/operate/naisdevice/how-to/install/index.html

Installs naisdevice on Windows using Scoop. This involves adding the nais scoop bucket and then installing the naisdevice package. Administrator access is required.

```shell
scoop bucket add nais https://github.com/nais/scoop-bucket
scoop install naisdevice
```

--------------------------------

### Postgres Configuration Example (YAML)

Source: https://docs.nais.io/persistence/postgresql/reference/index.html?q=

Example of a Postgres resource configuration in YAML format, specifying extensions for the database cluster.

```yaml
kind: Postgres
metadata:
  name: my-postgres-cluster
spec:
  cluster:
    ...
  database:
    extensions:
    - name: postgis
    - name: pgcrypto

```

--------------------------------

### Postgres Collation Configuration Example (YAML)

Source: https://docs.nais.io/persistence/postgresql/reference/index.html?q=

Example of configuring the database collation in a Postgres resource YAML file.

```yaml
kind: Postgres
metadata:
  name: my-postgres-cluster
spec:
  cluster:
    ...
  database:
    collation: nb_NO

```

--------------------------------

### Start Cloud SQL Proxy

Source: https://docs.nais.io/operate/cli/reference/postgres

Starts a proxy to a PostgreSQL instance by granting your user a timed 'sql.cloudsql.instanceUser' role. Requires a reason for access and allows specifying the local port and host.

```bash
nais postgres proxy --reason "debugging issue" appname
ais postgres proxy --reason "local development" --port 5433 --host 127.0.0.1 appname
```

--------------------------------

### Create Nais Application Manifest

Source: https://docs.nais.io/tutorials/hello-nais

This snippet demonstrates creating a directory for Nais configuration and an application manifest file (`app.yaml`). The manifest defines application settings like name, namespace, ingress, port, replicas, and resources.

```bash
mkdir .nais
touch .nais/app.yaml
```

```yaml
apiVersion: nais.io/v1alpha1
kind: Application
metadata:
  name: <MY-APP>
  namespace: <MY-TEAM>
spec:
  ingresses:
    - https://<MY-APP>.<MY-ENV>.nav.cloud.nais.io
  port: 8080
  ttl: 3h # Time before clean-up 
  replicas:
    max: 1
    min: 1
  resources:
    requests:
      cpu: 50m
      memory: 32Mi

```

--------------------------------

### Enable Auto-Instrumentation in Nais

Source: https://docs.nais.io/observability/tutorials/getting-started

Configure your nais.yaml to enable automatic instrumentation for your application. This injects OpenTelemetry agents, simplifying the setup of observability features.

```yaml
spec:
  observability:
    autoInstrumentation:
      enabled: true

```

--------------------------------

### Setup Postgres Migration (NAIS CLI)

Source: https://docs.nais.io/operate/cli/reference/postgres/index.html

Sets up a new target Postgres instance with updated configuration and enables continuous data replication from the source instance. This beta command requires the application name and the new instance name. Optional flags like tier, type, and disk-size can be specified.

```bash
nais postgres migrate setup appname new-instance-name
```

```bash
nais postgres migrate setup --tier $TIER --type $TYPE --disk-size $DISK_SIZE appname new-instance-name
```

--------------------------------

### kubectl get secret Failure Example

Source: https://docs.nais.io/workloads/how-to/troubleshooting/index.html

Example output of `kubectl get secret` when the secret is not found. It indicates a 'NotFound' error from the Kubernetes API server.

```bash
➜ kubectl get secret my-secret

Error from server (NotFound): secrets "my-secret" not found
```

--------------------------------

### Create GitHub Repository using GitHub CLI

Source: https://docs.nais.io/tutorials/hello-nais/index.html?q=

Creates a new private GitHub repository from the 'nais/hello-nais' template and clones it locally. Requires GitHub CLI to be installed and authenticated.

```bash
gh repo create <GITHUB-ORG>/<MY-APP> --template nais/hello-nais --private --clone
```

--------------------------------

### kubectl get secret Success Example

Source: https://docs.nais.io/workloads/how-to/troubleshooting/index.html

Example output of `kubectl get secret` when the secret is found. It displays the secret's name, type, data count, and age.

```bash
➜ kubectl get secret my-secret

NAME        TYPE     DATA  AGE
my-secret   Opaque   3     15h
```

--------------------------------

### Create Nais Application Manifest Directory

Source: https://docs.nais.io/tutorials/hello-nais/index.html?q=

Creates a '.nais' directory and an empty 'app.yaml' file within it. This file will define the application's configuration for the Nais platform.

```bash
mkdir .nais
touch .nais/app.yaml
```

--------------------------------

### Session Endpoint Request Example

Source: https://docs.nais.io/auth/reference

Example of an HTTP GET request to the session endpoint.

```http
GET /oauth2/session
```

--------------------------------

### GitHub Actions Workflow for Nais Deployment

Source: https://docs.nais.io/tutorials/hello-nais/index.html?q=

Defines a GitHub Actions workflow that checks for changes in '.nais/app.yaml', builds and pushes a Docker image, and deploys the application to Nais. It uses 'nais/what-changed@main', 'nais/docker-build-push@v0', and 'nais/deploy/actions/deploy@v2'. Requires placeholders like <MY-TEAM> and <MY-CLUSTER> to be replaced.

```yaml
name: Build and deploy
on:
  push:
    branches:
      - main
jobs:
  build_and_deploy:
    name: Build, push and deploy
    runs-on: ubuntu-latest
    permissions:
      contents: read
      id-token: write
      actions: read
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0 # Fetch all history for what-changed action
      - name: Determine what to do
        id: changed-files
        uses: "nais/what-changed@main"
        with:
          files: .nais/app.yaml
      - name: Build and push image and SBOM to OCI registry
        if: steps.changed-files.outputs.changed != 'only-inputs'
        uses: nais/docker-build-push@v0
        id: docker-build-push
        with:
          team: <MY-TEAM> # Replace
      - name: Deploy to Nais
        uses: nais/deploy/actions/deploy@v2
        env:
          CLUSTER: <MY-CLUSTER> # Replace 
          RESOURCE: .nais/app.yaml # This points to the file we created in the previous step
          WORKLOAD_IMAGE: ${{ steps.docker-build-push.outputs.image }}

```

--------------------------------

### Enable Auto-Instrumentation for Python

Source: https://docs.nais.io/observability/how-to/auto-instrumentation/index.html?q=

Enables auto-instrumentation for Python applications. This configuration requires the OpenTelemetry Agent to be set up with the 'python' runtime.

```yaml
spec:
  observability:
    autoInstrumentation:
      enabled: true
      runtime: python

```

--------------------------------

### Enable Auto-Instrumentation for Node.js

Source: https://docs.nais.io/observability/how-to/auto-instrumentation/index.html?q=

Enables auto-instrumentation for Node.js applications. This configuration requires the OpenTelemetry Agent to be set up with the 'nodejs' runtime.

```yaml
spec:
  observability:
    autoInstrumentation:
      enabled: true
      runtime: nodejs

```

--------------------------------

### Configure Readiness Probe

Source: https://docs.nais.io/workloads/application/reference/application-example

Defines the configuration for the readiness probe, which checks if an application instance is ready to serve traffic. Includes parameters like path, port, and timing thresholds.

```yaml
readiness:
  failureThreshold: 10
  initialDelay: 20
  path: /isready
  periodSeconds: 5
  port: 8080
  timeout: 1
```

--------------------------------

### Create Valkey Instance

Source: https://docs.nais.io/tags/index.html

Example YAML configuration for creating a Valkey (formerly Redis) instance within the NAIS platform. This defines the desired state for a Valkey deployment.

```yaml
apiVersion: "nais.io/v1"
kind: "ValkeyInstance"
metadata:
  name: "my-valkey-instance"
  namespace: "my-namespace"
spec:
  # Specify the desired size of the Valkey instance
  size: "small"
  # Define the number of replicas for high availability
  replicas: 3
```

--------------------------------

### Enable nav-logs Destination in Nais Application Manifest

Source: https://docs.nais.io/observability/logging/how-to/nav-logs-dashboards/index.html?q=

Configure your nais application manifest to enable logging to nav-logs (OpenSearch) by specifying the 'elastic' ID in the logging destinations. This is a YAML configuration snippet.

```yaml
spec:
  observability:
    logging:
      destinations:
        - id: elastic
```

--------------------------------

### Use Valkey in Workload

Source: https://docs.nais.io/tags/index.html

Demonstrates how to configure an application to connect to a Valkey instance. This involves specifying the Valkey instance name in the application's environment variables.

```yaml
apiVersion: "nais.io/v1"
kind: "Application"
metadata:
  name: "my-app"
  namespace: "my-namespace"
spec:
  image: "my-docker-image:latest"
  port: 8080
  env:
    - name: "VALKEY_HOST"
      value: "my-valkey-instance"
    - name: "VALKEY_PORT"
      value: "6379"
```

--------------------------------

### Querying CPU Usage in Prometheus (PromQL)

Source: https://docs.nais.io/persistence/opensearch/reference/index.html?q=

An example PromQL query to retrieve the CPU usage percentage for an OpenSearch instance. This query calculates idle CPU time and subtracts it from 100 to get the usage percentage. It assumes a specific naming convention for the service in Prometheus.

```promql
100 - avg by (cpu) (cpu_usage_idle{service="opensearch-<team>-<instance>"})
```

--------------------------------

### Connect to Database via psql

Source: https://docs.nais.io/persistence/postgresql/how-to/connect-from-laptop/index.html

Establishes a psql connection to the Postgres cluster. The `--reason` flag is used to provide context for the connection.

```bash
nais postgres psql --reason "debugging issue" <app-or-cluster-name>
```

--------------------------------

### Install naisdevice on macOS using Homebrew

Source: https://docs.nais.io/operate/naisdevice/how-to/install/index.html

Installs naisdevice on macOS by first tapping the nais/tap repository and then installing the naisdevice package using Homebrew. Requires Homebrew to be installed and administrator privileges for the password prompt.

```shell
brew tap nais/tap
brew install naisdevice
```

--------------------------------

### Create GitHub Actions Workflow for Nais Deployment

Source: https://docs.nais.io/tutorials/hello-nais

This snippet creates the necessary directory and file for a GitHub Actions workflow. The workflow is triggered on push to the main branch and includes steps to check changed files, build and push a Docker image, and deploy to Nais using the application manifest.

```bash
mkdir -p .github/workflows
touch .github/workflows/main.yaml
```

```yaml
name: Build and deploy
on:
  push:
    branches:
      - main
jobs:
  build_and_deploy:
    name: Build, push and deploy
    runs-on: ubuntu-latest
    permissions:
      contents: read
      id-token: write
      actions: read
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0 # Fetch all history for what-changed action
      - name: Determine what to do
        id: changed-files
        uses: "nais/what-changed@main"
        with:
          files: .nais/app.yaml
      - name: Build and push image and SBOM to OCI registry
        if: steps.changed-files.outputs.changed != 'only-inputs'
        uses: nais/docker-build-push@v0
        id: docker-build-push
        with:
          team: <MY-TEAM> # Replace
      - name: Deploy to Nais
        uses: nais/deploy/actions/deploy@v2
        env:
          CLUSTER: <MY-CLUSTER> # Replace 
          RESOURCE: .nais/app.yaml # This points to the file we created in the previous step
          WORKLOAD_IMAGE: ${{ steps.docker-build-push.outputs.image }}

```

--------------------------------

### Install nais-cli on macOS using Homebrew

Source: https://docs.nais.io/operate/cli/how-to/install/index.html

Installs the nais-cli on macOS using the Homebrew package manager. This involves tapping the nais repository and then installing the nais package.

```bash
brew tap nais/tap
brew install nais
```

--------------------------------

### Install nais-cli on Windows using Scoop

Source: https://docs.nais.io/operate/cli/how-to/install/index.html

Installs the nais-cli on Windows using the Scoop package manager. This involves adding the nais bucket to Scoop and then installing the nais-cli package.

```powershell
scoop bucket add nais https://github.com/nais/scoop-bucket
scoop install nais-cli
```

--------------------------------

### Navigate to Application Directory

Source: https://docs.nais.io/tutorials/hello-nais/index.html?q=

Changes the current directory to the newly created application repository. This is a standard shell command.

```bash
cd <MY-APP>
```

--------------------------------

### Install nais-cli on Ubuntu using APT

Source: https://docs.nais.io/operate/cli/how-to/install/index.html

Installs the nais-cli on Ubuntu using the APT package manager. This requires adding the nais PPA repository, updating the package list, and then installing the nais package.

```bash
NAIS_GPG_KEY="/etc/apt/keyrings/nav_nais_gar.asc"
curl -sfSL "https://europe-north1-apt.pkg.dev/doc/repo-signing-key.gpg" | sudo dd of="$NAIS_GPG_KEY"
echo "deb [arch=amd64 signed-by=$NAIS_GPG_KEY] https://europe-north1-apt.pkg.dev/projects/nais-io nais-ppa main" | sudo tee /etc/apt/sources.list.d/nav_nais_gar.list
sudo apt update
sudo apt install nais
```

--------------------------------

### Nais Application Manifest Configuration

Source: https://docs.nais.io/tutorials/hello-nais/index.html?q=

Defines the application's configuration for Nais, including its name, namespace, ingress, port, replica count, and resource requests. Placeholders like <MY-APP>, <MY-TEAM>, and <MY-ENV> need to be replaced with actual values.

```yaml
apiVersion: nais.io/v1alpha1
kind: Application
metadata:
  name: <MY-APP>
  namespace: <MY-TEAM>
spec:
  ingresses:
    - https://<MY-APP>.<MY-ENV>.nav.cloud.nais.io
  port: 8080
  ttl: 3h # Time before clean-up 
  replicas:
    max: 1
    min: 1
  resources:
    requests:
      cpu: 50m
      memory: 32Mi

```

--------------------------------

### Configure Logback for Team Logs

Source: https://docs.nais.io/observability/logging/how-to/team-logs/index.html

This Logback configuration sets up a `LogstashTcpSocketAppender` to send logs to the `team-logs` destination. It includes custom fields for Google Cloud project and NAIS environment details and uses a filter to conditionally send logs marked with `TEAM_LOGS`. A default console appender is also configured to handle logs without the `TEAM_LOGS` marker. The `logstash-logback-encoder` dependency is required.

```xml
<configuration>
  <appender name="team-logs" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
    <destination>team-logs.nais-system:5170</destination>
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
      <customFields>{"google_cloud_project":"${GOOGLE_CLOUD_PROJECT}","nais_namespace_name":"${NAIS_NAMESPACE}","nais_pod_name":"${NAIS_POD_NAME}","nais_container_name":"${NAIS_APP_NAME}"}</customFields>
      <includeContext>false</includeContext>
    </encoder>
    <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
      <evaluator class="ch.qos.logback.classic.boolex.OnMarkerEvaluator">
        <marker>TEAM_LOGS</marker>
      </evaluator>
      <OnMatch>ACCEPT</OnMatch>
      <OnMismatch>DENY</OnMismatch>
    </filter>
  </appender>

  <appender name="default-json" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder" />
    <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
      <evaluator class="ch.qos.logback.classic.boolex.OnMarkerEvaluator">
        <marker>TEAM_LOGS</marker>
      </evaluator>
      <OnMatch>DENY</OnMatch>
      <OnMismatch>ACCEPT</OnMismatch>
    </filter>
  </appender>

  <root level="INFO">
    <appender-ref ref="default-json" />
    <appender-ref ref="team-logs" />
  </root>

  <logger name="team-logs-logger" level="INFO" additivity="false">
    <appender-ref ref="team-logs" />
  </logger>
</configuration>
```

```xml
<dependency>
  <groupId>net.logstash.logback</groupId>
  <artifactId>logstash-logback-encoder</artifactId>
  <version>8.1</version>
</dependency>
```

--------------------------------

### Prepare PostgreSQL Instance for Access (NAIS CLI)

Source: https://docs.nais.io/persistence/cloudsql/how-to/personal-access

Prepares a PostgreSQL instance by connecting with application credentials and modifying permissions on the public schema. This allows all IAM users with correct GCP project permissions to connect. By default, only SELECT statements are allowed. Dependencies include nais-cli, kubectl, and optionally psql.

```bash
nais postgres prepare --team <TEAM> --environment <ENVIRONMENT> <MYAPP>

```

```bash
nais postgres prepare --team <TEAM> --environment <ENVIRONMENT> --schema <SCHEMA_NAME> <MYAPP>

```

```bash
nais postgres prepare --team <TEAM> --environment <ENVIRONMENT> --all-privileges <MYAPP>

```

--------------------------------

### Prepare PostgreSQL Instance

Source: https://docs.nais.io/operate/cli/reference/postgres

Prepares a PostgreSQL instance by modifying permissions on the public schema, allowing all IAM users in your GCP project to connect. This is a one-time operation per instance and schema.

```bash
nais postgres prepare appname
nais postgres prepare appname --schema my_schema
ais postgres prepare appname --all-privileges
```

--------------------------------

### Install Grafana Faro Web SDK Dependencies

Source: https://docs.nais.io/observability/frontend/index.html?q=

Installs the necessary packages for the Grafana Faro Web SDK and its tracing capabilities using npm. Ensure these are installed before initializing the SDK in your frontend application.

```bash
npm i -S @grafana/faro-web-sdk
npm i -S @grafana/faro-web-tracing
```

--------------------------------

### Handle Leader Election Events using Server Sent Events API (Kotlin, Python)

Source: https://docs.nais.io/services/leader-election/how-to/enable/index.html

This section provides examples for using the Server-Sent Events (SSE) API to subscribe to leader election changes. It includes a Kotlin example using Spring WebFlux and a Python example using the `sseclient` library. These examples demonstrate how to react to leader status updates.

```kotlin
@Service
class LederUtvelger :ApplicationListener<LeaderChangedEvent> {

    private val hostname = InetAddress.getLocalHost().hostName
    var erLeder : Boolean = false

    override fun onApplicationEvent(event: LeaderChangedEvent) {
        erLeder = event.leder == hostname
    }
}


@Component
class SSEHandler(builder: Builder, @Value("\${elector.sse.url}") uri: URI, publisher: ApplicationEventPublisher) {
    init {
        builder.build() 
            .get() 
            .uri(uri)
            .retrieve()
            .bodyToFlux(LederUtvelgerRespons::class.java).subscribe {
            publisher.publishEvent(LeaderChangedEvent(this,it.name))
        }
    }
    data class LederUtvelgerRespons(val name: String, val last_update: LocalDateTime)
    class LeaderChangedEvent(source: Any, val leder: String) : ApplicationEvent(source)
}

```

```python
import os
from typing import Callable

from sseclient import SSEClient


def subscribe_leader_election(handler: Callable[[str], None]):
    url = os.getenv("ELECTOR_SSE_URL")
    messages = SSEClient(url)
    for msg in messages:
        handler(msg)


```
Tokens:
Raw