gitlab.DeployKeyEnable

import pulumi
import pulumi_gitlab as gitlab

# A repo to host the deployment key
parent = gitlab.Project("parent", name="parent_project")
# A second repo to use the deployment key from the parent project
foo = gitlab.Project("foo", name="foo_project")
# Upload a deployment key for the parent repo
parent_deploy_key = gitlab.DeployKey("parent",
    project=parent.id,
    title="Example deploy key",
    key="ssh-ed25519 AAAA...")
# Enable the deployment key on the second repo
foo_deploy_key_enable = gitlab.DeployKeyEnable("foo",
    project=foo.id,
    key_id=parent_deploy_key.deploy_key_id)

package main

import (
	"github.com/pulumi/pulumi-gitlab/sdk/v8/go/gitlab"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// A repo to host the deployment key
		parent, err := gitlab.NewProject(ctx, "parent", &gitlab.ProjectArgs{
			Name: pulumi.String("parent_project"),
		})
		if err != nil {
			return err
		}
		// A second repo to use the deployment key from the parent project
		foo, err := gitlab.NewProject(ctx, "foo", &gitlab.ProjectArgs{
			Name: pulumi.String("foo_project"),
		})
		if err != nil {
			return err
		}
		// Upload a deployment key for the parent repo
		parentDeployKey, err := gitlab.NewDeployKey(ctx, "parent", &gitlab.DeployKeyArgs{
			Project: parent.ID(),
			Title:   pulumi.String("Example deploy key"),
			Key:     pulumi.String("ssh-ed25519 AAAA..."),
		})
		if err != nil {
			return err
		}
		// Enable the deployment key on the second repo
		_, err = gitlab.NewDeployKeyEnable(ctx, "foo", &gitlab.DeployKeyEnableArgs{
			Project: foo.ID(),
			KeyId:   parentDeployKey.DeployKeyId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // A repo to host the deployment key
    var parent = new GitLab.Project("parent", new()
    {
        Name = "parent_project",
    });

    // A second repo to use the deployment key from the parent project
    var foo = new GitLab.Project("foo", new()
    {
        Name = "foo_project",
    });

    // Upload a deployment key for the parent repo
    var parentDeployKey = new GitLab.DeployKey("parent", new()
    {
        Project = parent.Id,
        Title = "Example deploy key",
        Key = "ssh-ed25519 AAAA...",
    });

    // Enable the deployment key on the second repo
    var fooDeployKeyEnable = new GitLab.DeployKeyEnable("foo", new()
    {
        Project = foo.Id,
        KeyId = parentDeployKey.DeployKeyId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gitlab.Project;
import com.pulumi.gitlab.ProjectArgs;
import com.pulumi.gitlab.DeployKey;
import com.pulumi.gitlab.DeployKeyArgs;
import com.pulumi.gitlab.DeployKeyEnable;
import com.pulumi.gitlab.DeployKeyEnableArgs;
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) {
        // A repo to host the deployment key
        var parent = new Project("parent", ProjectArgs.builder()
            .name("parent_project")
            .build());

        // A second repo to use the deployment key from the parent project
        var foo = new Project("foo", ProjectArgs.builder()
            .name("foo_project")
            .build());

        // Upload a deployment key for the parent repo
        var parentDeployKey = new DeployKey("parentDeployKey", DeployKeyArgs.builder()
            .project(parent.id())
            .title("Example deploy key")
            .key("ssh-ed25519 AAAA...")
            .build());

        // Enable the deployment key on the second repo
        var fooDeployKeyEnable = new DeployKeyEnable("fooDeployKeyEnable", DeployKeyEnableArgs.builder()
            .project(foo.id())
            .keyId(parentDeployKey.deployKeyId())
            .build());

    }
}

resources:
  # A repo to host the deployment key
  parent:
    type: gitlab:Project
    properties:
      name: parent_project
  # A second repo to use the deployment key from the parent project
  foo:
    type: gitlab:Project
    properties:
      name: foo_project
  # Upload a deployment key for the parent repo
  parentDeployKey:
    type: gitlab:DeployKey
    name: parent
    properties:
      project: ${parent.id}
      title: Example deploy key
      key: ssh-ed25519 AAAA...
  # Enable the deployment key on the second repo
  fooDeployKeyEnable:
    type: gitlab:DeployKeyEnable
    name: foo
    properties:
      project: ${foo.id}
      keyId: ${parentDeployKey.deployKeyId}

var deployKeyEnableResource = new GitLab.DeployKeyEnable("deployKeyEnableResource", new()
{
    KeyId = "string",
    Project = "string",
    CanPush = false,
    Key = "string",
    Title = "string",
});

example, err := gitlab.NewDeployKeyEnable(ctx, "deployKeyEnableResource", &gitlab.DeployKeyEnableArgs{
	KeyId:   pulumi.String("string"),
	Project: pulumi.String("string"),
	CanPush: pulumi.Bool(false),
	Key:     pulumi.String("string"),
	Title:   pulumi.String("string"),
})

var deployKeyEnableResource = new DeployKeyEnable("deployKeyEnableResource", DeployKeyEnableArgs.builder()
    .keyId("string")
    .project("string")
    .canPush(false)
    .key("string")
    .title("string")
    .build());

deploy_key_enable_resource = gitlab.DeployKeyEnable("deployKeyEnableResource",
    key_id="string",
    project="string",
    can_push=False,
    key="string",
    title="string")

type: gitlab:DeployKeyEnable
properties:
    canPush: false
    key: string
    keyId: string
    project: string
    title: string