Terraform Data Sources

# Get all available images
data "danubedata_vps_images" "available" {}

# Output all image names
output "available_images" {
  value = data.danubedata_vps_images.available.images[*].image
}

# Use in a VPS resource
resource "danubedata_vps" "web" {
  name       = "web-server"
  image      = data.danubedata_vps_images.available.images[0].image
  datacenter = "fsn1"
  # ...
}

data "danubedata_vps_images" "available" {}

# Find Ubuntu images
locals {
  ubuntu_images = [
    for img in data.danubedata_vps_images.available.images :
    img if img.distro == "ubuntu"
  ]
}

output "ubuntu_images" {
  value = local.ubuntu_images[*].image
}

data "danubedata_cache_providers" "available" {}

output "cache_providers" {
  value = data.danubedata_cache_providers.available.providers[*].name
}

# Find a specific provider
locals {
  redis_provider = [
    for p in data.danubedata_cache_providers.available.providers :
    p if p.type == "redis"
  ][0]
}

output "redis_default_port" {
  value = local.redis_provider.default_port
}

data "danubedata_database_providers" "available" {}

output "database_engines" {
  value = data.danubedata_database_providers.available.providers[*].name
}

# Find PostgreSQL info
locals {
  postgresql = [
    for p in data.danubedata_database_providers.available.providers :
    p if p.type == "postgresql"
  ][0]
}

output "postgresql_default_port" {
  value = local.postgresql.default_port
}

data "danubedata_ssh_keys" "all" {}

output "ssh_key_names" {
  value = data.danubedata_ssh_keys.all.ssh_keys[*].name
}

# Find a specific key by name
locals {
  deploy_key = [
    for key in data.danubedata_ssh_keys.all.ssh_keys :
    key if key.name == "deploy-key"
  ]
}

# Use existing key in VPS
resource "danubedata_vps" "web" {
  name        = "web-server"
  image       = "ubuntu-24.04"
  datacenter  = "fsn1"
  auth_method = "ssh_key"
  ssh_key_id  = local.deploy_key[0].id
  # ...
}

data "danubedata_ssh_keys" "existing" {}

# Create key only if it doesn't exist
resource "danubedata_ssh_key" "deploy" {
  count = length([
    for k in data.danubedata_ssh_keys.existing.ssh_keys :
    k if k.name == "deploy-key"
  ]) == 0 ? 1 : 0

  name       = "deploy-key"
  public_key = file("~/.ssh/id_ed25519.pub")
}

variable "servers" {
  type = map(object({
    image    = string
    profile  = string
  }))
  default = {
    "web" = {
      image   = "ubuntu-24.04"
      profile = "small_shared"
    }
    "api" = {
      image   = "debian-12"
      profile = "medium_shared"
    }
  }
}

data "danubedata_ssh_keys" "all" {}

resource "danubedata_vps" "servers" {
  for_each = var.servers

  name             = each.key
  image            = each.value.image
  resource_profile = each.value.profile
  datacenter       = "fsn1"
  auth_method      = "ssh_key"
  ssh_key_id       = data.danubedata_ssh_keys.all.ssh_keys[0].id
}

data "danubedata_vps_images" "available" {}

locals {
  has_alpine = length([
    for img in data.danubedata_vps_images.available.images :
    img if img.distro == "alpine"
  ]) > 0
}

resource "danubedata_vps" "alpine" {
  count = local.has_alpine ? 1 : 0

  name       = "alpine-server"
  image      = "alpine-3.20"
  datacenter = "fsn1"
  # ...
}

data "danubedata_vps_images" "available" {}

locals {
  images        = data.danubedata_vps_images.available.images
  ubuntu_latest = [for img in local.images : img if img.image == "ubuntu-24.04"][0]
}

data "danubedata_ssh_keys" "team_keys" {}

locals {
  production_key = [
    for key in data.danubedata_ssh_keys.team_keys.ssh_keys :
    key if key.name == "production-deploy"
  ][0]
}

data "danubedata_ssh_keys" "all" {}

locals {
  has_keys   = length(data.danubedata_ssh_keys.all.ssh_keys) > 0
  first_key  = local.has_keys ? data.danubedata_ssh_keys.all.ssh_keys[0] : null
}