civo.ObjectStoreCredential

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

return await Deployment.RunAsync(() => 
{
    var backupObjectStoreCredential = Civo.GetObjectStoreCredential.Invoke(new()
    {
        Name = "backup-server",
    });

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

    // Use the credential to create a bucket
    var backupObjectStore = new Civo.ObjectStore("backupObjectStore", new()
    {
        MaxSizeGb = 500,
        Region = "LON1",
        AccessKeyId = backupIndex / objectStoreCredentialObjectStoreCredential.AccessKeyId,
    });

});

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 {
		_, err := civo.LookupObjectStoreCredential(ctx, &civo.LookupObjectStoreCredentialArgs{
			Name: pulumi.StringRef("backup-server"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = civo.NewObjectStoreCredential(ctx, "backupIndex/objectStoreCredentialObjectStoreCredential", &civo.ObjectStoreCredentialArgs{
			AccessKeyId:     pulumi.String("my-access-key"),
			SecretAccessKey: pulumi.String("my-secret-key"),
		})
		if err != nil {
			return err
		}
		_, err = civo.NewObjectStore(ctx, "backupObjectStore", &civo.ObjectStoreArgs{
			MaxSizeGb:   pulumi.Int(500),
			Region:      pulumi.String("LON1"),
			AccessKeyId: backupIndex / objectStoreCredentialObjectStoreCredential.AccessKeyId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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) {
        final var backupObjectStoreCredential = CivoFunctions.getObjectStoreCredential(GetObjectStoreCredentialArgs.builder()
            .name("backup-server")
            .build());

        var backupIndex_objectStoreCredentialObjectStoreCredential = new ObjectStoreCredential("backupIndex/objectStoreCredentialObjectStoreCredential", ObjectStoreCredentialArgs.builder()        
            .accessKeyId("my-access-key")
            .secretAccessKey("my-secret-key")
            .build());

        var backupObjectStore = new ObjectStore("backupObjectStore", ObjectStoreArgs.builder()        
            .maxSizeGb(500)
            .region("LON1")
            .accessKeyId(backupIndex / objectStoreCredentialObjectStoreCredential.accessKeyId())
            .build());

    }
}

import pulumi
import pulumi_civo as civo

backup_object_store_credential = civo.get_object_store_credential(name="backup-server")
# Create a credential for the object store with a specific access key and secret key
backup_index_object_store_credential_object_store_credential = civo.ObjectStoreCredential("backupIndex/objectStoreCredentialObjectStoreCredential",
    access_key_id="my-access-key",
    secret_access_key="my-secret-key")
# Use the credential to create a bucket
backup_object_store = civo.ObjectStore("backupObjectStore",
    max_size_gb=500,
    region="LON1",
    access_key_id=backup_index / object_store_credential_object_store_credential["accessKeyId"])

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

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