Harbor v3.9.1, May 30 23

Harbor v3.9.1 published on Tuesday, May 30, 2023 by Pulumiverse

harbor.RobotAccount

Explore with Pulumi AI

Harbor v3.9.1 published on Tuesday, May 30, 2023 by Pulumiverse

# Resource: harbor.RobotAccount

Harbor supports different levels of robot accounts. Currently system and project level robot accounts are supported.

Example Usage

System Level

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Harbor = Pulumiverse.Harbor;
using Random = Pulumi.Random;

return await Deployment.RunAsync(() => 
{
    var password = new Random.RandomPassword("password", new()
    {
        Length = 12,
        Special = false,
    });

    var main = new Harbor.Project("main");

    var system = new Harbor.RobotAccount("system", new()
    {
        Description = "system level robot account",
        Level = "system",
        Secret = resource.Random_password.Password.Result,
        Permissions = new[]
        {
            new Harbor.Inputs.RobotAccountPermissionArgs
            {
                Accesses = new[]
                {
                    new Harbor.Inputs.RobotAccountPermissionAccessArgs
                    {
                        Action = "create",
                        Resource = "labels",
                    },
                },
                Kind = "system",
                Namespace = "/",
            },
            new Harbor.Inputs.RobotAccountPermissionArgs
            {
                Accesses = new[]
                {
                    new Harbor.Inputs.RobotAccountPermissionAccessArgs
                    {
                        Action = "push",
                        Resource = "repository",
                    },
                    new Harbor.Inputs.RobotAccountPermissionAccessArgs
                    {
                        Action = "read",
                        Resource = "helm-chart",
                    },
                    new Harbor.Inputs.RobotAccountPermissionAccessArgs
                    {
                        Action = "read",
                        Resource = "helm-chart-version",
                    },
                },
                Kind = "project",
                Namespace = main.Name,
            },
            new Harbor.Inputs.RobotAccountPermissionArgs
            {
                Accesses = new[]
                {
                    new Harbor.Inputs.RobotAccountPermissionAccessArgs
                    {
                        Action = "pull",
                        Resource = "repository",
                    },
                },
                Kind = "project",
                Namespace = "*",
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-harbor/sdk/v3/go/harbor"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := random.NewRandomPassword(ctx, "password", &random.RandomPasswordArgs{
			Length:  pulumi.Int(12),
			Special: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		main, err := harbor.NewProject(ctx, "main", nil)
		if err != nil {
			return err
		}
		_, err = harbor.NewRobotAccount(ctx, "system", &harbor.RobotAccountArgs{
			Description: pulumi.String("system level robot account"),
			Level:       pulumi.String("system"),
			Secret:      pulumi.Any(resource.Random_password.Password.Result),
			Permissions: harbor.RobotAccountPermissionArray{
				&harbor.RobotAccountPermissionArgs{
					Accesses: harbor.RobotAccountPermissionAccessArray{
						&harbor.RobotAccountPermissionAccessArgs{
							Action:   pulumi.String("create"),
							Resource: pulumi.String("labels"),
						},
					},
					Kind:      pulumi.String("system"),
					Namespace: pulumi.String("/"),
				},
				&harbor.RobotAccountPermissionArgs{
					Accesses: harbor.RobotAccountPermissionAccessArray{
						&harbor.RobotAccountPermissionAccessArgs{
							Action:   pulumi.String("push"),
							Resource: pulumi.String("repository"),
						},
						&harbor.RobotAccountPermissionAccessArgs{
							Action:   pulumi.String("read"),
							Resource: pulumi.String("helm-chart"),
						},
						&harbor.RobotAccountPermissionAccessArgs{
							Action:   pulumi.String("read"),
							Resource: pulumi.String("helm-chart-version"),
						},
					},
					Kind:      pulumi.String("project"),
					Namespace: main.Name,
				},
				&harbor.RobotAccountPermissionArgs{
					Accesses: harbor.RobotAccountPermissionAccessArray{
						&harbor.RobotAccountPermissionAccessArgs{
							Action:   pulumi.String("pull"),
							Resource: pulumi.String("repository"),
						},
					},
					Kind:      pulumi.String("project"),
					Namespace: pulumi.String("*"),
				},
			},
		})
		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.random.RandomPassword;
import com.pulumi.random.RandomPasswordArgs;
import com.pulumi.harbor.Project;
import com.pulumi.harbor.RobotAccount;
import com.pulumi.harbor.RobotAccountArgs;
import com.pulumi.harbor.inputs.RobotAccountPermissionArgs;
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) {
        var password = new RandomPassword("password", RandomPasswordArgs.builder()        
            .length(12)
            .special(false)
            .build());

        var main = new Project("main");

        var system = new RobotAccount("system", RobotAccountArgs.builder()        
            .description("system level robot account")
            .level("system")
            .secret(resource.random_password().password().result())
            .permissions(            
                RobotAccountPermissionArgs.builder()
                    .accesses(RobotAccountPermissionAccessArgs.builder()
                        .action("create")
                        .resource("labels")
                        .build())
                    .kind("system")
                    .namespace("/")
                    .build(),
                RobotAccountPermissionArgs.builder()
                    .accesses(                    
                        RobotAccountPermissionAccessArgs.builder()
                            .action("push")
                            .resource("repository")
                            .build(),
                        RobotAccountPermissionAccessArgs.builder()
                            .action("read")
                            .resource("helm-chart")
                            .build(),
                        RobotAccountPermissionAccessArgs.builder()
                            .action("read")
                            .resource("helm-chart-version")
                            .build())
                    .kind("project")
                    .namespace(main.name())
                    .build(),
                RobotAccountPermissionArgs.builder()
                    .accesses(RobotAccountPermissionAccessArgs.builder()
                        .action("pull")
                        .resource("repository")
                        .build())
                    .kind("project")
                    .namespace("*")
                    .build())
            .build());

    }
}

import pulumi
import pulumi_random as random
import pulumiverse_harbor as harbor

password = random.RandomPassword("password",
    length=12,
    special=False)
main = harbor.Project("main")
system = harbor.RobotAccount("system",
    description="system level robot account",
    level="system",
    secret=resource["random_password"]["password"]["result"],
    permissions=[
        harbor.RobotAccountPermissionArgs(
            accesses=[harbor.RobotAccountPermissionAccessArgs(
                action="create",
                resource="labels",
            )],
            kind="system",
            namespace="/",
        ),
        harbor.RobotAccountPermissionArgs(
            accesses=[
                harbor.RobotAccountPermissionAccessArgs(
                    action="push",
                    resource="repository",
                ),
                harbor.RobotAccountPermissionAccessArgs(
                    action="read",
                    resource="helm-chart",
                ),
                harbor.RobotAccountPermissionAccessArgs(
                    action="read",
                    resource="helm-chart-version",
                ),
            ],
            kind="project",
            namespace=main.name,
        ),
        harbor.RobotAccountPermissionArgs(
            accesses=[harbor.RobotAccountPermissionAccessArgs(
                action="pull",
                resource="repository",
            )],
            kind="project",
            namespace="*",
        ),
    ])

import * as pulumi from "@pulumi/pulumi";
import * as harbor from "@pulumiverse/harbor";
import * as random from "@pulumi/random";

const password = new random.RandomPassword("password", {
    length: 12,
    special: false,
});
const main = new harbor.Project("main", {});
const system = new harbor.RobotAccount("system", {
    description: "system level robot account",
    level: "system",
    secret: resource.random_password.password.result,
    permissions: [
        {
            accesses: [{
                action: "create",
                resource: "labels",
            }],
            kind: "system",
            namespace: "/",
        },
        {
            accesses: [
                {
                    action: "push",
                    resource: "repository",
                },
                {
                    action: "read",
                    resource: "helm-chart",
                },
                {
                    action: "read",
                    resource: "helm-chart-version",
                },
            ],
            kind: "project",
            namespace: main.name,
        },
        {
            accesses: [{
                action: "pull",
                resource: "repository",
            }],
            kind: "project",
            namespace: "*",
        },
    ],
});

resources:
  password:
    type: random:RandomPassword
    properties:
      length: 12
      special: false
  main:
    type: harbor:Project
  system:
    type: harbor:RobotAccount
    properties:
      description: system level robot account
      level: system
      secret: ${resource.random_password.password.result}
      permissions:
        - accesses:
            - action: create
              resource: labels
          kind: system
          namespace: /
        - accesses:
            - action: push
              resource: repository
            - action: read
              resource: helm-chart
            - action: read
              resource: helm-chart-version
          kind: project
          namespace: ${main.name}
        - accesses:
            - action: pull
              resource: repository
          kind: project
          namespace: '*'

Project Level

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Harbor = Pulumiverse.Harbor;

return await Deployment.RunAsync(() => 
{
    var main = new Harbor.Project("main");

    var project = new Harbor.RobotAccount("project", new()
    {
        Description = "project level robot account",
        Level = "project",
        Permissions = new[]
        {
            new Harbor.Inputs.RobotAccountPermissionArgs
            {
                Accesses = new[]
                {
                    new Harbor.Inputs.RobotAccountPermissionAccessArgs
                    {
                        Action = "pull",
                        Resource = "repository",
                    },
                    new Harbor.Inputs.RobotAccountPermissionAccessArgs
                    {
                        Action = "push",
                        Resource = "repository",
                    },
                },
                Kind = "project",
                Namespace = main.Name,
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-harbor/sdk/v3/go/harbor"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := harbor.NewProject(ctx, "main", nil)
		if err != nil {
			return err
		}
		_, err = harbor.NewRobotAccount(ctx, "project", &harbor.RobotAccountArgs{
			Description: pulumi.String("project level robot account"),
			Level:       pulumi.String("project"),
			Permissions: harbor.RobotAccountPermissionArray{
				&harbor.RobotAccountPermissionArgs{
					Accesses: harbor.RobotAccountPermissionAccessArray{
						&harbor.RobotAccountPermissionAccessArgs{
							Action:   pulumi.String("pull"),
							Resource: pulumi.String("repository"),
						},
						&harbor.RobotAccountPermissionAccessArgs{
							Action:   pulumi.String("push"),
							Resource: pulumi.String("repository"),
						},
					},
					Kind:      pulumi.String("project"),
					Namespace: main.Name,
				},
			},
		})
		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.harbor.Project;
import com.pulumi.harbor.RobotAccount;
import com.pulumi.harbor.RobotAccountArgs;
import com.pulumi.harbor.inputs.RobotAccountPermissionArgs;
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) {
        var main = new Project("main");

        var project = new RobotAccount("project", RobotAccountArgs.builder()        
            .description("project level robot account")
            .level("project")
            .permissions(RobotAccountPermissionArgs.builder()
                .accesses(                
                    RobotAccountPermissionAccessArgs.builder()
                        .action("pull")
                        .resource("repository")
                        .build(),
                    RobotAccountPermissionAccessArgs.builder()
                        .action("push")
                        .resource("repository")
                        .build())
                .kind("project")
                .namespace(main.name())
                .build())
            .build());

    }
}

import pulumi
import pulumiverse_harbor as harbor

main = harbor.Project("main")
project = harbor.RobotAccount("project",
    description="project level robot account",
    level="project",
    permissions=[harbor.RobotAccountPermissionArgs(
        accesses=[
            harbor.RobotAccountPermissionAccessArgs(
                action="pull",
                resource="repository",
            ),
            harbor.RobotAccountPermissionAccessArgs(
                action="push",
                resource="repository",
            ),
        ],
        kind="project",
        namespace=main.name,
    )])

import * as pulumi from "@pulumi/pulumi";
import * as harbor from "@pulumiverse/harbor";

const main = new harbor.Project("main", {});
const project = new harbor.RobotAccount("project", {
    description: "project level robot account",
    level: "project",
    permissions: [{
        accesses: [
            {
                action: "pull",
                resource: "repository",
            },
            {
                action: "push",
                resource: "repository",
            },
        ],
        kind: "project",
        namespace: main.name,
    }],
});

resources:
  main:
    type: harbor:Project
  project:
    type: harbor:RobotAccount
    properties:
      description: project level robot account
      level: project
      permissions:
        - accesses:
            - action: pull
              resource: repository
            - action: push
              resource: repository
          kind: project
          namespace: ${main.name}

Create RobotAccount Resource

new RobotAccount(name: string, args: RobotAccountArgs, opts?: CustomResourceOptions);

@overload
def RobotAccount(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 description: Optional[str] = None,
                 disable: Optional[bool] = None,
                 duration: Optional[int] = None,
                 level: Optional[str] = None,
                 name: Optional[str] = None,
                 permissions: Optional[Sequence[RobotAccountPermissionArgs]] = None,
                 secret: Optional[str] = None)
@overload
def RobotAccount(resource_name: str,
                 args: RobotAccountArgs,
                 opts: Optional[ResourceOptions] = None)

func NewRobotAccount(ctx *Context, name string, args RobotAccountArgs, opts ...ResourceOption) (*RobotAccount, error)

public RobotAccount(string name, RobotAccountArgs args, CustomResourceOptions? opts = null)

public RobotAccount(String name, RobotAccountArgs args)
public RobotAccount(String name, RobotAccountArgs args, CustomResourceOptions options)

type: harbor:RobotAccount
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

name string: The unique name of the resource.
args RobotAccountArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
args RobotAccountArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args RobotAccountArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args RobotAccountArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args RobotAccountArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

RobotAccount Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

The RobotAccount resource accepts the following input properties:

Level string
Permissions List<Pulumiverse.Harbor.Inputs.RobotAccountPermissionArgs>
Description string
Disable bool
Duration int
Name string
Secret string

Level string
Permissions []RobotAccountPermissionArgs
Description string
Disable bool
Duration int
Name string
Secret string

level String
permissions List<RobotAccountPermissionArgs>
description String
disable Boolean
duration Integer
name String
secret String

level string
permissions RobotAccountPermissionArgs[]
description string
disable boolean
duration number
name string
secret string

level str
permissions Sequence[RobotAccountPermissionArgs]
description str
disable bool
duration int
name str
secret str

level String
permissions List<Property Map>
description String
disable Boolean
duration Number
name String
secret String

Outputs

All input properties are implicitly available as output properties. Additionally, the RobotAccount resource produces the following output properties:

FullName string
Id string: The provider-assigned unique ID for this managed resource.
RobotId string

FullName string
Id string: The provider-assigned unique ID for this managed resource.
RobotId string

fullName String
id String: The provider-assigned unique ID for this managed resource.
robotId String

fullName string
id string: The provider-assigned unique ID for this managed resource.
robotId string

full_name str
id str: The provider-assigned unique ID for this managed resource.
robot_id str

fullName String
id String: The provider-assigned unique ID for this managed resource.
robotId String

Look up Existing RobotAccount Resource

Get an existing RobotAccount resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: RobotAccountState, opts?: CustomResourceOptions): RobotAccount

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        description: Optional[str] = None,
        disable: Optional[bool] = None,
        duration: Optional[int] = None,
        full_name: Optional[str] = None,
        level: Optional[str] = None,
        name: Optional[str] = None,
        permissions: Optional[Sequence[RobotAccountPermissionArgs]] = None,
        robot_id: Optional[str] = None,
        secret: Optional[str] = None) -> RobotAccount

func GetRobotAccount(ctx *Context, name string, id IDInput, state *RobotAccountState, opts ...ResourceOption) (*RobotAccount, error)

public static RobotAccount Get(string name, Input<string> id, RobotAccountState? state, CustomResourceOptions? opts = null)

public static RobotAccount get(String name, Output<String> id, RobotAccountState state, CustomResourceOptions options)

Resource lookup is not supported in YAML

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

resource_name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

The following state arguments are supported:

Description string
Disable bool
Duration int
FullName string
Level string
Name string
Permissions List<Pulumiverse.Harbor.Inputs.RobotAccountPermissionArgs>
RobotId string
Secret string

Description string
Disable bool
Duration int
FullName string
Level string
Name string
Permissions []RobotAccountPermissionArgs
RobotId string
Secret string

description String
disable Boolean
duration Integer
fullName String
level String
name String
permissions List<RobotAccountPermissionArgs>
robotId String
secret String

description string
disable boolean
duration number
fullName string
level string
name string
permissions RobotAccountPermissionArgs[]
robotId string
secret string

description str
disable bool
duration int
full_name str
level str
name str
permissions Sequence[RobotAccountPermissionArgs]
robot_id str
secret str

description String
disable Boolean
duration Number
fullName String
level String
name String
permissions List<Property Map>
robotId String
secret String

Supporting Types

RobotAccountPermission

Accesses List<Pulumiverse.Harbor.Inputs.RobotAccountPermissionAccess>
Kind string
Namespace string

Accesses []RobotAccountPermissionAccess
Kind string
Namespace string

accesses List<RobotAccountPermissionAccess>
kind String
namespace String

accesses RobotAccountPermissionAccess[]
kind string
namespace string

accesses Sequence[RobotAccountPermissionAccess]
kind str
namespace str

accesses List<Property Map>
kind String
namespace String

RobotAccountPermissionAccess

Action string
Resource string
Effect string

Action string
Resource string
Effect string

action String
resource String
effect String

action string
resource string
effect string

action str
resource str
effect str

action String
resource String
effect String

Package Details

Repository: harbor pulumiverse/pulumi-harbor
License: Apache-2.0
Notes: This Pulumi package is based on the harbor Terraform Provider.

Harbor v3.9.1 published on Tuesday, May 30, 2023 by Pulumiverse

pulumiverse/pulumi-harbor

harbor.RobotAccount

On this page

On this page

# Resource: harbor.RobotAccount

Example Usage

System Level

Project Level

Create RobotAccount Resource

RobotAccount Resource Properties

Inputs

Outputs

Look up Existing RobotAccount Resource

Supporting Types

RobotAccountPermission

RobotAccountPermissionAccess

Package Details

On this page

On this page