terraform-provider-stackitprivatepreview/docs/guides/using_loadbalancer_with_observability.md

page_title
Using the STACKIT Loadbalancer together with STACKIT Observability

Using the STACKIT Loadbalancer together with STACKIT Observability

Overview

This guide explains how to configure the STACKIT Loadbalancer product to send metrics and logs to a STACKIT Observability instance.

1. Set Up Providers

   Begin by configuring the STACKIT provider to connect to the STACKIT services.

   provider "stackit" {
     default_region = "eu01"
   }
   

2. Create an Observability instance

   Establish a STACKIT Observability instance and its credentials.

   resource "stackit_observability_instance" "observability01" {
     project_id                             = var.project_id_prod
     name                                   = "example-instance"
     plan_name                              = "Observability-Monitoring-Medium-EU01"
     acl                                    = ["0.0.0.0/0"]
     metrics_retention_days                 = 30
     metrics_retention_days_5m_downsampling = 10
     metrics_retention_days_1h_downsampling = 5
   }
   
   resource "stackit_observability_credential" "observability01-credential" {
     project_id                             = var.project_id_prod
     instance_id = stackit_observability_instance.observability01.instance_id
   }
   

3. Create STACKIT Loadbalancer credentials reference

   Create a STACKIT Loadbalancer credentials which will be used in the STACKIT Loadbalancer resource as a reference.

    resource "stackit_loadbalancer_observability_credential" "example" {
      project_id   = var.project_id_prod
      display_name = "example-credentials"
      username     = stackit_observability_credential.observability01-credential.username
      password     = stackit_observability_credential.observability01-credential.password
    }
   

4. Create the STACKIT Loadbalancer

   # Create a network
   resource "stackit_network" "example_network" {
     project_id       = var.project_id_prod
     name             = "example-network"
     ipv4_nameservers = ["8.8.8.8"]
     ipv4_prefix      = "192.168.0.0/25"
     labels = {
       "key" = "value"
     }
     routed = true
   }
   
   # Create a network interface
   resource "stackit_network_interface" "nic" {
     project_id   = var.project_id_prod
     network_id = stackit_network.example_network.network_id
   }
   
   # Create a public IP for the load balancer
   resource "stackit_public_ip" "public-ip" {
     project_id   = var.project_id_prod
     lifecycle {
       ignore_changes = [network_interface_id]
     }
   }
   
   # Create a key pair for accessing the server instance
   resource "stackit_key_pair" "keypair" {
     name       = "example-key-pair"
     # set the path of your public key file here
     public_key = chomp(file("/home/bob/.ssh/id_ed25519.pub"))
   }
   
   # Create a server instance
   resource "stackit_server" "boot-from-image" {
     project_id   = var.project_id_prod
     name       = "example-server"
     boot_volume = {
       size        = 64
       source_type = "image"
       source_id   = "59838a89-51b1-4892-b57f-b3caf598ee2f" // Ubuntu 24.04
     }
     availability_zone = "eu01-1"
     machine_type      = "g1.1"
     keypair_name      = stackit_key_pair.keypair.name
   }
   
   # Attach the network interface to the server
   resource "stackit_server_network_interface_attach" "nic-attachment" {
     project_id   = var.project_id_prod
     server_id            = stackit_server.boot-from-image.server_id
     network_interface_id = stackit_network_interface.nic.network_interface_id
   }
   
   # Create a load balancer
   resource "stackit_loadbalancer" "example" {
     project_id   = var.project_id_prod
     name       = "example-load-balancer"
     target_pools = [
       {
         name        = "example-target-pool"
         target_port = 80
         targets = [
           {
             display_name = stackit_server.boot-from-image.name
             ip           = stackit_network_interface.nic.ipv4
           }
         ]
         active_health_check = {
           healthy_threshold   = 10
           interval            = "3s"
           interval_jitter     = "3s"
           timeout             = "3s"
           unhealthy_threshold = 10
         }
       }
     ]
     listeners = [
       {
         display_name = "example-listener"
         port         = 80
         protocol     = "PROTOCOL_TCP"
         target_pool  = "example-target-pool"
       }
     ]
     networks = [
       {
         network_id = stackit_network.example_network.network_id
         role       = "ROLE_LISTENERS_AND_TARGETS"
       }
     ]
     external_address = stackit_public_ip.public-ip.ip
     options = {
       private_network_only = false
       observability = {
   	     logs = {
   	        # uses the load balancer credential from the last step
   	     	credentials_ref = stackit_loadbalancer_observability_credential.example.credentials_ref
   	     	# uses the observability instance from step 1
   	     	push_url = stackit_observability_instance.observability01.logs_push_url
   	     }
   	     metrics = {
   	        # uses the load balancer credential from the last step
   	     	credentials_ref = stackit_loadbalancer_observability_credential.example.credentials_ref
   	     	# uses the observability instance from step 1
   	     	push_url = stackit_observability_instance.observability01.metrics_push_url
   	     }
       }
     }
   }