civo.ObjectStoreCredential

import * as pulumi from "@pulumi/pulumi";
import * as civo from "@pulumi/civo";

// Create a simple credential for the object store
const backup = civo.getObjectStoreCredential({
    name: "backup-server",
});
// Create a credential for the object store with a specific access key and secret key
const backupObjectStoreCredential = new civo.ObjectStoreCredential("backup", {
    name: "backup-server",
    accessKeyId: "my-access-key",
    secretAccessKey: "my-secret-key",
});
// Use the credential to create a bucket
const backupObjectStore = new civo.ObjectStore("backup", {
    name: "backup-server",
    maxSizeGb: 500,
    region: "LON1",
    accessKeyId: backupObjectStoreCredential.accessKeyId,
});

import pulumi
import pulumi_civo as civo

# Create a simple credential for the object store
backup = civo.get_object_store_credential(name="backup-server")
# Create a credential for the object store with a specific access key and secret key
backup_object_store_credential = civo.ObjectStoreCredential("backup",
    name="backup-server",
    access_key_id="my-access-key",
    secret_access_key="my-secret-key")
# Use the credential to create a bucket
backup_object_store = civo.ObjectStore("backup",
    name="backup-server",
    max_size_gb=500,
    region="LON1",
    access_key_id=backup_object_store_credential.access_key_id)

package main

import (
	"github.com/pulumi/pulumi-civo/sdk/v2/go/civo"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a simple credential for the object store
		_, err := civo.LookupObjectStoreCredential(ctx, &civo.LookupObjectStoreCredentialArgs{
			Name: pulumi.StringRef("backup-server"),
		}, nil)
		if err != nil {
			return err
		}
		// Create a credential for the object store with a specific access key and secret key
		backupObjectStoreCredential, err := civo.NewObjectStoreCredential(ctx, "backup", &civo.ObjectStoreCredentialArgs{
			Name:            pulumi.String("backup-server"),
			AccessKeyId:     pulumi.String("my-access-key"),
			SecretAccessKey: pulumi.String("my-secret-key"),
		})
		if err != nil {
			return err
		}
		// Use the credential to create a bucket
		_, err = civo.NewObjectStore(ctx, "backup", &civo.ObjectStoreArgs{
			Name:        pulumi.String("backup-server"),
			MaxSizeGb:   pulumi.Int(500),
			Region:      pulumi.String("LON1"),
			AccessKeyId: backupObjectStoreCredential.AccessKeyId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Civo = Pulumi.Civo;

return await Deployment.RunAsync(() => 
{
    // Create a simple credential for the object store
    var backup = Civo.GetObjectStoreCredential.Invoke(new()
    {
        Name = "backup-server",
    });

    // Create a credential for the object store with a specific access key and secret key
    var backupObjectStoreCredential = new Civo.ObjectStoreCredential("backup", new()
    {
        Name = "backup-server",
        AccessKeyId = "my-access-key",
        SecretAccessKey = "my-secret-key",
    });

    // Use the credential to create a bucket
    var backupObjectStore = new Civo.ObjectStore("backup", new()
    {
        Name = "backup-server",
        MaxSizeGb = 500,
        Region = "LON1",
        AccessKeyId = backupObjectStoreCredential.AccessKeyId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.civo.CivoFunctions;
import com.pulumi.civo.inputs.GetObjectStoreCredentialArgs;
import com.pulumi.civo.ObjectStoreCredential;
import com.pulumi.civo.ObjectStoreCredentialArgs;
import com.pulumi.civo.ObjectStore;
import com.pulumi.civo.ObjectStoreArgs;
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) {
        // Create a simple credential for the object store
        final var backup = CivoFunctions.getObjectStoreCredential(GetObjectStoreCredentialArgs.builder()
            .name("backup-server")
            .build());

        // Create a credential for the object store with a specific access key and secret key
        var backupObjectStoreCredential = new ObjectStoreCredential("backupObjectStoreCredential", ObjectStoreCredentialArgs.builder()
            .name("backup-server")
            .accessKeyId("my-access-key")
            .secretAccessKey("my-secret-key")
            .build());

        // Use the credential to create a bucket
        var backupObjectStore = new ObjectStore("backupObjectStore", ObjectStoreArgs.builder()
            .name("backup-server")
            .maxSizeGb(500)
            .region("LON1")
            .accessKeyId(backupObjectStoreCredential.accessKeyId())
            .build());

    }
}

resources:
  # Create a credential for the object store with a specific access key and secret key
  backupObjectStoreCredential:
    type: civo:ObjectStoreCredential
    name: backup
    properties:
      name: backup-server
      accessKeyId: my-access-key
      secretAccessKey: my-secret-key
  # Use the credential to create a bucket
  backupObjectStore:
    type: civo:ObjectStore
    name: backup
    properties:
      name: backup-server
      maxSizeGb: 500
      region: LON1
      accessKeyId: ${backupObjectStoreCredential.accessKeyId}
variables:
  # Create a simple credential for the object store
  backup:
    fn::invoke:
      Function: civo:getObjectStoreCredential
      Arguments:
        name: backup-server

var objectStoreCredentialResource = new Civo.ObjectStoreCredential("objectStoreCredentialResource", new()
{
    AccessKeyId = "string",
    Name = "string",
    Region = "string",
    SecretAccessKey = "string",
});

example, err := civo.NewObjectStoreCredential(ctx, "objectStoreCredentialResource", &civo.ObjectStoreCredentialArgs{
	AccessKeyId:     pulumi.String("string"),
	Name:            pulumi.String("string"),
	Region:          pulumi.String("string"),
	SecretAccessKey: pulumi.String("string"),
})

var objectStoreCredentialResource = new ObjectStoreCredential("objectStoreCredentialResource", ObjectStoreCredentialArgs.builder()
    .accessKeyId("string")
    .name("string")
    .region("string")
    .secretAccessKey("string")
    .build());

object_store_credential_resource = civo.ObjectStoreCredential("objectStoreCredentialResource",
    access_key_id="string",
    name="string",
    region="string",
    secret_access_key="string")

const objectStoreCredentialResource = new civo.ObjectStoreCredential("objectStoreCredentialResource", {
    accessKeyId: "string",
    name: "string",
    region: "string",
    secretAccessKey: "string",
});

type: civo:ObjectStoreCredential
properties:
    accessKeyId: string
    name: string
    region: string
    secretAccessKey: string