Onboard Load Balancer (part 4: acc tests, examples and documentation) (#117)

* Implement acceptance test

* Add resource and data source to the provider

* Add examples and markdown description

* Generate docs

* Adjustments after review

* Move load balancer supporting infrastructure from resource config to example
This commit is contained in:
João Palet 2023-10-31 18:13:50 +01:00 committed by GitHub
parent b804dc789e
commit 7188e13e92
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 831 additions and 0 deletions

View file

@ -195,6 +195,38 @@ func (r *loadBalancerResource) Schema(_ context.Context, _ resource.SchemaReques
resp.Schema = schema.Schema{
Description: descriptions["main"],
MarkdownDescription: `
## Setting up supporting infrastructure` + "\n" + `
### Configuring an OpenStack provider` + "\n" + `
To automate the creation of load balancers, OpenStack can be used to setup the supporting infrastructure.
To set up the OpenStack provider, you can create a token through the STACKIT Portal, in your project's Infrastructure API page.
There, the OpenStack user domain name, username, and password are generated and can be obtained. The provider can then be configured as follows:` + "\n" +
"```terraform" + `
terraform {
required_providers {
(...)
openstack = {
source = "terraform-provider-openstack/openstack"
}
}
}
provider "openstack" {
user_domain_name = "{OpenStack user domain name}"
user_name = "{OpenStack username}"
password = "{OpenStack password}"
region = "RegionOne"
auth_url = "https://keystone.api.iaas.eu01.stackit.cloud/v3"
}
` + "\n```" + `
### Configuring the supporting infrastructure
The example below uses OpenStack to create the network, router, a public IP address and a compute instance.
`,
Attributes: map[string]schema.Attribute{
"id": schema.StringAttribute{
Description: descriptions["id"],

View file

@ -0,0 +1,322 @@
package loadbalancer_test
import (
"context"
"fmt"
"testing"
"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
"github.com/hashicorp/terraform-plugin-testing/helper/resource"
"github.com/hashicorp/terraform-plugin-testing/terraform"
"github.com/stackitcloud/stackit-sdk-go/core/config"
"github.com/stackitcloud/stackit-sdk-go/services/loadbalancer"
"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/testutil"
)
// Instance resource data
var loadBalancerResource = map[string]string{
"project_id": testutil.ProjectId,
"name": fmt.Sprintf("tf-acc-%s", acctest.RandStringFromCharSet(7, acctest.CharSetAlphaNum)),
"target_pool_name": "example-target-pool",
"target_port": "5432",
"target_port_updated": "5431",
"target_display_name": "example-target",
"healthy_threshold": "3",
"interval": "10s",
"interval_jitter": "5s",
"timeout": "10s",
"unhealthy_threshold": "3",
"listener_display_name": "example-listener",
"listener_port": "5432",
"listener_protocol": "PROTOCOL_TCP",
"network_role": "ROLE_LISTENERS_AND_TARGETS",
"private_network_only": "true",
}
func configResources(targetPort string) string {
return fmt.Sprintf(`
%s
%s
resource "stackit_loadbalancer" "loadbalancer" {
project_id = "%s"
name = "%s"
target_pools = [
{
name = "%s"
target_port = %s
targets = [
{
display_name = "%s"
ip = openstack_compute_instance_v2.example.network.0.fixed_ip_v4
}
]
active_health_check = {
healthy_threshold = %s
interval = "%s"
interval_jitter = "%s"
timeout = "%s"
unhealthy_threshold = %s
}
}
]
listeners = [
{
display_name = "%s"
port = %s
protocol = "%s"
target_pool = "%s"
}
]
networks = [
{
network_id = openstack_networking_network_v2.example.id
role = "%s"
}
]
options = {
private_network_only = %s
}
}
`,
supportingInfraResources(loadBalancerResource["name"], OpenStack{
userDomainName: testutil.OSUserDomainName,
userName: testutil.OSUserName,
password: testutil.OSPassword,
}),
testutil.LoadBalancerProviderConfig(),
loadBalancerResource["project_id"],
loadBalancerResource["name"],
loadBalancerResource["target_pool_name"],
targetPort,
loadBalancerResource["target_display_name"],
loadBalancerResource["healthy_threshold"],
loadBalancerResource["interval"],
loadBalancerResource["interval_jitter"],
loadBalancerResource["timeout"],
loadBalancerResource["unhealthy_threshold"],
loadBalancerResource["listener_display_name"],
loadBalancerResource["listener_port"],
loadBalancerResource["listener_protocol"],
loadBalancerResource["target_pool_name"],
loadBalancerResource["network_role"],
loadBalancerResource["private_network_only"],
)
}
func supportingInfraResources(name string, os OpenStack) string {
return fmt.Sprintf(`
provider "openstack" {
user_domain_name = "%s"
user_name = "%s"
password = "%s"
region = "RegionOne"
auth_url = "https://keystone.api.iaas.eu01.stackit.cloud/v3"
}
# Create a network
resource "openstack_networking_network_v2" "example" {
name = "%s_network"
}
resource "openstack_networking_subnet_v2" "example" {
name = "%s_subnet"
cidr = "192.168.0.0/25"
dns_nameservers = ["8.8.8.8"]
network_id = openstack_networking_network_v2.example.id
}
data "openstack_networking_network_v2" "public" {
name = "floating-net"
}
resource "openstack_networking_floatingip_v2" "example_ip" {
pool = data.openstack_networking_network_v2.public.name
}
# Create an instance
data "openstack_compute_flavor_v2" "example" {
name = "g1.1"
}
resource "openstack_compute_instance_v2" "example" {
depends_on = [openstack_networking_subnet_v2.example]
name = "%s_instance"
flavor_id = data.openstack_compute_flavor_v2.example.id
admin_pass = "example"
security_groups = ["default"]
block_device {
uuid = "4364cdb2-dacd-429b-803e-f0f7cfde1c24" // Ubuntu 22.04
volume_size = 32
source_type = "image"
destination_type = "volume"
delete_on_termination = true
}
network {
name = openstack_networking_network_v2.example.name
}
lifecycle {
ignore_changes = [security_groups]
}
}
resource "openstack_networking_router_v2" "example_router" {
name = "%s_router"
admin_state_up = "true"
external_network_id = data.openstack_networking_network_v2.public.id
}
resource "openstack_networking_router_interface_v2" "example_interface" {
router_id = openstack_networking_router_v2.example_router.id
subnet_id = openstack_networking_subnet_v2.example.id
}
`,
os.userDomainName, os.userName, os.password, name, name, name, name)
}
func TestAccLoadBalancerResource(t *testing.T) {
resource.Test(t, resource.TestCase{
ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
ExternalProviders: map[string]resource.ExternalProvider{
"openstack": {
VersionConstraint: "= 1.52.1",
Source: "terraform-provider-openstack/openstack",
},
},
CheckDestroy: testAccCheckLoadBalancerDestroy,
Steps: []resource.TestStep{
// Creation
{
Config: configResources(loadBalancerResource["target_port"]),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "project_id", loadBalancerResource["project_id"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "name", loadBalancerResource["name"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.name", loadBalancerResource["target_pool_name"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.target_port", loadBalancerResource["target_port"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.targets.0.display_name", loadBalancerResource["target_display_name"]),
resource.TestCheckResourceAttrSet("stackit_loadbalancer.loadbalancer", "target_pools.0.targets.0.ip"),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.healthy_threshold", loadBalancerResource["healthy_threshold"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.interval", loadBalancerResource["interval"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.interval_jitter", loadBalancerResource["interval_jitter"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.timeout", loadBalancerResource["timeout"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.unhealthy_threshold", loadBalancerResource["unhealthy_threshold"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "listeners.0.display_name", loadBalancerResource["listener_display_name"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "listeners.0.port", loadBalancerResource["listener_port"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "listeners.0.protocol", loadBalancerResource["listener_protocol"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "listeners.0.target_pool", loadBalancerResource["target_pool_name"]),
resource.TestCheckResourceAttrSet("stackit_loadbalancer.loadbalancer", "networks.0.network_id"),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "networks.0.role", loadBalancerResource["network_role"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "options.private_network_only", loadBalancerResource["private_network_only"]),
),
},
// Data source
{
Config: fmt.Sprintf(`
%s
data "stackit_loadbalancer" "loadbalancer" {
project_id = stackit_loadbalancer.loadbalancer.project_id
name = stackit_loadbalancer.loadbalancer.name
}
`,
configResources(loadBalancerResource["target_port"]),
),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "project_id", loadBalancerResource["project_id"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "name", loadBalancerResource["name"]),
resource.TestCheckResourceAttrPair(
"data.stackit_loadbalancer.loadbalancer", "project_id",
"stackit_loadbalancer.loadbalancer", "project_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_loadbalancer.loadbalancer", "name",
"stackit_loadbalancer.loadbalancer", "name",
),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.name", loadBalancerResource["target_pool_name"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.target_port", loadBalancerResource["target_port"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.targets.0.display_name", loadBalancerResource["target_display_name"]),
resource.TestCheckResourceAttrSet("data.stackit_loadbalancer.loadbalancer", "target_pools.0.targets.0.ip"),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.healthy_threshold", loadBalancerResource["healthy_threshold"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.interval", loadBalancerResource["interval"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.interval_jitter", loadBalancerResource["interval_jitter"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.timeout", loadBalancerResource["timeout"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.unhealthy_threshold", loadBalancerResource["unhealthy_threshold"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "listeners.0.display_name", loadBalancerResource["listener_display_name"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "listeners.0.port", loadBalancerResource["listener_port"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "listeners.0.protocol", loadBalancerResource["listener_protocol"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "listeners.0.target_pool", loadBalancerResource["target_pool_name"]),
resource.TestCheckResourceAttrSet("data.stackit_loadbalancer.loadbalancer", "networks.0.network_id"),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "networks.0.role", loadBalancerResource["network_role"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "options.private_network_only", loadBalancerResource["private_network_only"]),
),
},
// Import
{
ResourceName: "stackit_loadbalancer.loadbalancer",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_loadbalancer.loadbalancer"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_loadbalancer.loadbalancer")
}
name, ok := r.Primary.Attributes["name"]
if !ok {
return "", fmt.Errorf("couldn't find attribute name")
}
return fmt.Sprintf("%s,%s", testutil.ProjectId, name), nil
},
ImportState: true,
ImportStateVerify: true,
},
// Update
{
Config: configResources(loadBalancerResource["target_port_updated"]),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "project_id", loadBalancerResource["project_id"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "name", loadBalancerResource["name"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.target_port", loadBalancerResource["target_port_updated"]),
),
},
// Deletion is done by the framework implicitly
},
})
}
type OpenStack struct {
userDomainName string
userName string
password string
}
func testAccCheckLoadBalancerDestroy(_ *terraform.State) error {
ctx := context.Background()
var client *loadbalancer.APIClient
var err error
if testutil.LoadBalancerCustomEndpoint == "" {
client, err = loadbalancer.NewAPIClient(
config.WithRegion("eu01"),
)
} else {
client, err = loadbalancer.NewAPIClient(
config.WithEndpoint(testutil.LoadBalancerCustomEndpoint),
)
}
if err != nil {
return fmt.Errorf("creating client: %w", err)
}
// Disabling loadbalancer functionality will delete all load balancers
_, err = client.DisableLoadBalancingExecute(ctx, testutil.ProjectId)
if err != nil {
return fmt.Errorf("disabling loadbalancer functionality: %w", err)
}
return nil
}

View file

@ -50,6 +50,13 @@ var (
ResourceManagerCustomEndpoint = os.Getenv("TF_ACC_RESOURCEMANAGER_CUSTOM_ENDPOINT")
SecretsManagerCustomEndpoint = os.Getenv("TF_ACC_SECRETSMANAGER_CUSTOM_ENDPOINT")
SKECustomEndpoint = os.Getenv("TF_ACC_SKE_CUSTOM_ENDPOINT")
// OpenStack user domain name
OSUserDomainName = os.Getenv("TF_ACC_OS_USER_DOMAIN_NAME")
// OpenStack user name
OSUserName = os.Getenv("TF_ACC_OS_USER_NAME")
// OpenStack password
OSPassword = os.Getenv("TF_ACC_OS_PASSWORD")
)
// Provider config helper functions

View file

@ -14,6 +14,7 @@ import (
argusScrapeConfig "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/argus/scrapeconfig"
dnsRecordSet "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/dns/recordset"
dnsZone "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/dns/zone"
loadBalancer "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/loadbalancer/loadbalancer"
logMeCredential "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/logme/credential"
logMeInstance "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/logme/instance"
mariaDBCredential "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/mariadb/credential"
@ -341,6 +342,7 @@ func (p *Provider) DataSources(_ context.Context) []func() datasource.DataSource
argusScrapeConfig.NewScrapeConfigDataSource,
dnsZone.NewZoneDataSource,
dnsRecordSet.NewRecordSetDataSource,
loadBalancer.NewLoadBalancerDataSource,
logMeInstance.NewInstanceDataSource,
logMeCredential.NewCredentialDataSource,
mariaDBInstance.NewInstanceDataSource,
@ -376,6 +378,7 @@ func (p *Provider) Resources(_ context.Context) []func() resource.Resource {
argusScrapeConfig.NewScrapeConfigResource,
dnsZone.NewZoneResource,
dnsRecordSet.NewRecordSetResource,
loadBalancer.NewLoadBalancerResource,
logMeInstance.NewInstanceResource,
logMeCredential.NewCredentialResource,
mariaDBInstance.NewInstanceResource,