prefect.ServiceAccount

import * as pulumi from "@pulumi/pulumi";
import * as prefect from "@pulumi/prefect";
import * as time from "@pulumi/time";

// NON-EXPIRING API KEY
const example = new prefect.ServiceAccount("example", {});
const ninetyDays = new time.index.Time_rotating("ninetyDays", {rotationDays: 90});
// Pass the time_rotating resource to the `api_key_expiration` attribute
// in order to automate the rotation of the Service Account key
const exampleRotateTimeKey = new prefect.ServiceAccount("exampleRotateTimeKey", {apiKeyExpiration: ninetyDays.rotationRfc3339});
// Optionally, rotate non-expiring Service Account keys
// using the `api_key_keepers` attribute, which is an
// arbitrary map of values that, if changed, will
// trigger a key rotation (but not a re-creation of the Service Account)
const exampleRotateForeverKey = new prefect.ServiceAccount("exampleRotateForeverKey", {
    apiKeyExpiration: undefined,
    apiKeyKeepers: {
        foo: "value-1",
        bar: "value-2",
    },
});
// Use the optional `old_key_expires_in_seconds`, which applies
// a TTL to the old key when rotation takes place.
// This is useful to ensure that your consumers don't experience
// downtime when the new key is being rolled out.
const exampleOldKeyExpiresLater = new prefect.ServiceAccount("exampleOldKeyExpiresLater", {
    oldKeyExpiresInSeconds: 300,
    apiKeyExpiration: ninetyDays.rotationRfc3339,
    apiKeyKeepers: {
        foo: "value-1",
        bar: "value-2",
    },
});

import pulumi
import pulumi_prefect as prefect
import pulumi_time as time

# NON-EXPIRING API KEY
example = prefect.ServiceAccount("example")
ninety_days = time.index.Time_rotating("ninetyDays", rotation_days=90)
# Pass the time_rotating resource to the `api_key_expiration` attribute
# in order to automate the rotation of the Service Account key
example_rotate_time_key = prefect.ServiceAccount("exampleRotateTimeKey", api_key_expiration=ninety_days["rotationRfc3339"])
# Optionally, rotate non-expiring Service Account keys
# using the `api_key_keepers` attribute, which is an
# arbitrary map of values that, if changed, will
# trigger a key rotation (but not a re-creation of the Service Account)
example_rotate_forever_key = prefect.ServiceAccount("exampleRotateForeverKey",
    api_key_expiration=None,
    api_key_keepers={
        "foo": "value-1",
        "bar": "value-2",
    })
# Use the optional `old_key_expires_in_seconds`, which applies
# a TTL to the old key when rotation takes place.
# This is useful to ensure that your consumers don't experience
# downtime when the new key is being rolled out.
example_old_key_expires_later = prefect.ServiceAccount("exampleOldKeyExpiresLater",
    old_key_expires_in_seconds=300,
    api_key_expiration=ninety_days["rotationRfc3339"],
    api_key_keepers={
        "foo": "value-1",
        "bar": "value-2",
    })

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/prefect/v2/prefect"
	"github.com/pulumi/pulumi-time/sdk/go/time"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// NON-EXPIRING API KEY
		_, err := prefect.NewServiceAccount(ctx, "example", nil)
		if err != nil {
			return err
		}
		ninetyDays, err := time.NewTime_rotating(ctx, "ninetyDays", &time.Time_rotatingArgs{
			RotationDays: 90,
		})
		if err != nil {
			return err
		}
		// Pass the time_rotating resource to the `api_key_expiration` attribute
		// in order to automate the rotation of the Service Account key
		_, err = prefect.NewServiceAccount(ctx, "exampleRotateTimeKey", &prefect.ServiceAccountArgs{
			ApiKeyExpiration: ninetyDays.RotationRfc3339,
		})
		if err != nil {
			return err
		}
		// Optionally, rotate non-expiring Service Account keys
		// using the `api_key_keepers` attribute, which is an
		// arbitrary map of values that, if changed, will
		// trigger a key rotation (but not a re-creation of the Service Account)
		_, err = prefect.NewServiceAccount(ctx, "exampleRotateForeverKey", &prefect.ServiceAccountArgs{
			ApiKeyExpiration: nil,
			ApiKeyKeepers: pulumi.StringMap{
				"foo": pulumi.String("value-1"),
				"bar": pulumi.String("value-2"),
			},
		})
		if err != nil {
			return err
		}
		// Use the optional `old_key_expires_in_seconds`, which applies
		// a TTL to the old key when rotation takes place.
		// This is useful to ensure that your consumers don't experience
		// downtime when the new key is being rolled out.
		_, err = prefect.NewServiceAccount(ctx, "exampleOldKeyExpiresLater", &prefect.ServiceAccountArgs{
			OldKeyExpiresInSeconds: pulumi.Float64(300),
			ApiKeyExpiration:       ninetyDays.RotationRfc3339,
			ApiKeyKeepers: pulumi.StringMap{
				"foo": pulumi.String("value-1"),
				"bar": pulumi.String("value-2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Prefect = Pulumi.Prefect;
using Time = Pulumi.Time;

return await Deployment.RunAsync(() => 
{
    // NON-EXPIRING API KEY
    var example = new Prefect.ServiceAccount("example");

    var ninetyDays = new Time.Index.Time_rotating("ninetyDays", new()
    {
        RotationDays = 90,
    });

    // Pass the time_rotating resource to the `api_key_expiration` attribute
    // in order to automate the rotation of the Service Account key
    var exampleRotateTimeKey = new Prefect.ServiceAccount("exampleRotateTimeKey", new()
    {
        ApiKeyExpiration = ninetyDays.RotationRfc3339,
    });

    // Optionally, rotate non-expiring Service Account keys
    // using the `api_key_keepers` attribute, which is an
    // arbitrary map of values that, if changed, will
    // trigger a key rotation (but not a re-creation of the Service Account)
    var exampleRotateForeverKey = new Prefect.ServiceAccount("exampleRotateForeverKey", new()
    {
        ApiKeyExpiration = null,
        ApiKeyKeepers = 
        {
            { "foo", "value-1" },
            { "bar", "value-2" },
        },
    });

    // Use the optional `old_key_expires_in_seconds`, which applies
    // a TTL to the old key when rotation takes place.
    // This is useful to ensure that your consumers don't experience
    // downtime when the new key is being rolled out.
    var exampleOldKeyExpiresLater = new Prefect.ServiceAccount("exampleOldKeyExpiresLater", new()
    {
        OldKeyExpiresInSeconds = 300,
        ApiKeyExpiration = ninetyDays.RotationRfc3339,
        ApiKeyKeepers = 
        {
            { "foo", "value-1" },
            { "bar", "value-2" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.prefect.ServiceAccount;
import com.pulumi.time.time_rotating;
import com.pulumi.time.Time_rotatingArgs;
import com.pulumi.prefect.ServiceAccountArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // NON-EXPIRING API KEY
        var example = new ServiceAccount("example");

        var ninetyDays = new Time_rotating("ninetyDays", Time_rotatingArgs.builder()
            .rotationDays(90)
            .build());

        // Pass the time_rotating resource to the `api_key_expiration` attribute
        // in order to automate the rotation of the Service Account key
        var exampleRotateTimeKey = new ServiceAccount("exampleRotateTimeKey", ServiceAccountArgs.builder()
            .apiKeyExpiration(ninetyDays.rotationRfc3339())
            .build());

        // Optionally, rotate non-expiring Service Account keys
        // using the `api_key_keepers` attribute, which is an
        // arbitrary map of values that, if changed, will
        // trigger a key rotation (but not a re-creation of the Service Account)
        var exampleRotateForeverKey = new ServiceAccount("exampleRotateForeverKey", ServiceAccountArgs.builder()
            .apiKeyExpiration(null)
            .apiKeyKeepers(Map.ofEntries(
                Map.entry("foo", "value-1"),
                Map.entry("bar", "value-2")
            ))
            .build());

        // Use the optional `old_key_expires_in_seconds`, which applies
        // a TTL to the old key when rotation takes place.
        // This is useful to ensure that your consumers don't experience
        // downtime when the new key is being rolled out.
        var exampleOldKeyExpiresLater = new ServiceAccount("exampleOldKeyExpiresLater", ServiceAccountArgs.builder()
            .oldKeyExpiresInSeconds(300)
            .apiKeyExpiration(ninetyDays.rotationRfc3339())
            .apiKeyKeepers(Map.ofEntries(
                Map.entry("foo", "value-1"),
                Map.entry("bar", "value-2")
            ))
            .build());

    }
}

resources:
  # NON-EXPIRING API KEY
  example:
    type: prefect:ServiceAccount
  ninetyDays:
    type: time:time_rotating
    properties:
      rotationDays: 90
  # Pass the time_rotating resource to the `api_key_expiration` attribute
  # in order to automate the rotation of the Service Account key
  exampleRotateTimeKey:
    type: prefect:ServiceAccount
    properties:
      apiKeyExpiration: ${ninetyDays.rotationRfc3339}
  # Optionally, rotate non-expiring Service Account keys
  # using the `api_key_keepers` attribute, which is an
  # arbitrary map of values that, if changed, will
  # trigger a key rotation (but not a re-creation of the Service Account)
  exampleRotateForeverKey:
    type: prefect:ServiceAccount
    properties:
      apiKeyExpiration: null
      # never expires
      apiKeyKeepers:
        foo: value-1
        bar: value-2
  # Use the optional `old_key_expires_in_seconds`, which applies
  # a TTL to the old key when rotation takes place.
  # This is useful to ensure that your consumers don't experience
  # downtime when the new key is being rolled out.
  exampleOldKeyExpiresLater:
    type: prefect:ServiceAccount
    properties:
      oldKeyExpiresInSeconds: 300
      # Remember that `old_key_expires_in_seconds` is only applied
      #   # when a key rotation takes place, such as changing the
      #   # `api_key_expiration` attribute
      apiKeyExpiration: ${ninetyDays.rotationRfc3339}
      # or the `api_key_keepers` attribute
      apiKeyKeepers:
        foo: value-1
        bar: value-2

var serviceAccountResource = new Prefect.ServiceAccount("serviceAccountResource", new()
{
    AccountId = "string",
    AccountRoleName = "string",
    ApiKeyExpiration = "string",
    ApiKeyKeepers = 
    {
        { "string", "string" },
    },
    Name = "string",
    OldKeyExpiresInSeconds = 0,
});

example, err := prefect.NewServiceAccount(ctx, "serviceAccountResource", &prefect.ServiceAccountArgs{
AccountId: pulumi.String("string"),
AccountRoleName: pulumi.String("string"),
ApiKeyExpiration: pulumi.String("string"),
ApiKeyKeepers: pulumi.StringMap{
"string": pulumi.String("string"),
},
Name: pulumi.String("string"),
OldKeyExpiresInSeconds: pulumi.Float64(0),
})

var serviceAccountResource = new ServiceAccount("serviceAccountResource", ServiceAccountArgs.builder()
    .accountId("string")
    .accountRoleName("string")
    .apiKeyExpiration("string")
    .apiKeyKeepers(Map.of("string", "string"))
    .name("string")
    .oldKeyExpiresInSeconds(0)
    .build());

service_account_resource = prefect.ServiceAccount("serviceAccountResource",
    account_id="string",
    account_role_name="string",
    api_key_expiration="string",
    api_key_keepers={
        "string": "string",
    },
    name="string",
    old_key_expires_in_seconds=0)

const serviceAccountResource = new prefect.ServiceAccount("serviceAccountResource", {
    accountId: "string",
    accountRoleName: "string",
    apiKeyExpiration: "string",
    apiKeyKeepers: {
        string: "string",
    },
    name: "string",
    oldKeyExpiresInSeconds: 0,
});

type: prefect:ServiceAccount
properties:
    accountId: string
    accountRoleName: string
    apiKeyExpiration: string
    apiKeyKeepers:
        string: string
    name: string
    oldKeyExpiresInSeconds: 0