Project

import * as pulumi from "@pulumi/pulumi";
import * as gitlab from "@pulumi/gitlab";
const example = new gitlab.Project("example", {
    description: "My awesome codebase",
    visibilityLevel: "public",
});
// Project with custom push rules
const example_two = new gitlab.Project("example-two", {pushRules: {
    authorEmailRegex: "@example\\.com$",
    commitCommitterCheck: true,
    memberCheck: true,
    preventSecrets: true,
}});
const peterParker = gitlab.getUser({
    username: "peter_parker",
});
const petersRepo = new gitlab.Project("petersRepo", {
    description: "This is a description",
    namespaceId: peterParker.then(peterParker => peterParker.namespaceId),
});
// Fork a project
const forkProject = new gitlab.Project("forkProject", {
    description: "This is a fork",
    forkedFromProjectId: example.id,
});
// Fork a project and setup a pull mirror
const forkIndex_projectProject = new gitlab.Project("forkIndex/projectProject", {
    description: "This is a fork",
    forkedFromProjectId: example.id,
    importUrl: example.httpUrlToRepo,
    mirror: true,
});
// Create a project by importing it from a public project
const importPublic = new gitlab.Project("importPublic", {importUrl: "https://gitlab.example.com/repo.git"});
// Create a project by importing it from a public project and setup the pull mirror
const importPublicWithMirror = new gitlab.Project("importPublicWithMirror", {
    importUrl: "https://gitlab.example.com/repo.git",
    mirror: true,
});
// Create a project by importing it from a private project
const importPrivateProject = new gitlab.Project("importPrivateProject", {
    importUrl: "https://gitlab.example.com/repo.git",
    importUrlUsername: "user",
    importUrlPassword: "pass",
});
// Create a project by importing it from a private project and setup the pull mirror
const importPrivateWithMirror = new gitlab.Project("importPrivateWithMirror", {
    importUrl: "https://gitlab.example.com/repo.git",
    importUrlUsername: "user",
    importUrlPassword: "pass",
    mirror: true,
});
// Create a project by importing it from a private project and provide credentials in `import_url`
// NOTE: only use this if you really must, use `import_url_username` and `import_url_password` whenever possible
//       GitLab API will always return the `import_url` without credentials, therefore you must ignore the `import_url` for changes:
const importPrivateIndex_projectProject = new gitlab.Project("importPrivateIndex/projectProject", {importUrl: "https://user:pass@gitlab.example.com/repo.git"});

import pulumi
import pulumi_gitlab as gitlab
example = gitlab.Project("example",
    description="My awesome codebase",
    visibility_level="public")
# Project with custom push rules
example_two = gitlab.Project("example-two", push_rules=gitlab.ProjectPushRulesArgs(
    author_email_regex="@example\\.com$",
    commit_committer_check=True,
    member_check=True,
    prevent_secrets=True,
))
peter_parker = gitlab.get_user(username="peter_parker")
peters_repo = gitlab.Project("petersRepo",
    description="This is a description",
    namespace_id=peter_parker.namespace_id)
# Fork a project
fork_project = gitlab.Project("forkProject",
    description="This is a fork",
    forked_from_project_id=example.id)
# Fork a project and setup a pull mirror
fork_index_project_project = gitlab.Project("forkIndex/projectProject",
    description="This is a fork",
    forked_from_project_id=example.id,
    import_url=example.http_url_to_repo,
    mirror=True)
# Create a project by importing it from a public project
import_public = gitlab.Project("importPublic", import_url="https://gitlab.example.com/repo.git")
# Create a project by importing it from a public project and setup the pull mirror
import_public_with_mirror = gitlab.Project("importPublicWithMirror",
    import_url="https://gitlab.example.com/repo.git",
    mirror=True)
# Create a project by importing it from a private project
import_private_project = gitlab.Project("importPrivateProject",
    import_url="https://gitlab.example.com/repo.git",
    import_url_username="user",
    import_url_password="pass")
# Create a project by importing it from a private project and setup the pull mirror
import_private_with_mirror = gitlab.Project("importPrivateWithMirror",
    import_url="https://gitlab.example.com/repo.git",
    import_url_username="user",
    import_url_password="pass",
    mirror=True)
# Create a project by importing it from a private project and provide credentials in `import_url`
# NOTE: only use this if you really must, use `import_url_username` and `import_url_password` whenever possible
#       GitLab API will always return the `import_url` without credentials, therefore you must ignore the `import_url` for changes:
import_private_index_project_project = gitlab.Project("importPrivateIndex/projectProject", import_url="https://user:pass@gitlab.example.com/repo.git")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using GitLab = Pulumi.GitLab;
return await Deployment.RunAsync(() =>
{
    var example = new GitLab.Project("example", new()
    {
        Description = "My awesome codebase",
        VisibilityLevel = "public",
    });
    // Project with custom push rules
    var example_two = new GitLab.Project("example-two", new()
    {
        PushRules = new GitLab.Inputs.ProjectPushRulesArgs
        {
            AuthorEmailRegex = "@example\\.com$",
            CommitCommitterCheck = true,
            MemberCheck = true,
            PreventSecrets = true,
        },
    });
    var peterParker = GitLab.GetUser.Invoke(new()
    {
        Username = "peter_parker",
    });
    var petersRepo = new GitLab.Project("petersRepo", new()
    {
        Description = "This is a description",
        NamespaceId = peterParker.Apply(getUserResult => getUserResult.NamespaceId),
    });
    // Fork a project
    var forkProject = new GitLab.Project("forkProject", new()
    {
        Description = "This is a fork",
        ForkedFromProjectId = example.Id,
    });
    // Fork a project and setup a pull mirror
    var forkIndex_projectProject = new GitLab.Project("forkIndex/projectProject", new()
    {
        Description = "This is a fork",
        ForkedFromProjectId = example.Id,
        ImportUrl = example.HttpUrlToRepo,
        Mirror = true,
    });
    // Create a project by importing it from a public project
    var importPublic = new GitLab.Project("importPublic", new()
    {
        ImportUrl = "https://gitlab.example.com/repo.git",
    });
    // Create a project by importing it from a public project and setup the pull mirror
    var importPublicWithMirror = new GitLab.Project("importPublicWithMirror", new()
    {
        ImportUrl = "https://gitlab.example.com/repo.git",
        Mirror = true,
    });
    // Create a project by importing it from a private project
    var importPrivateProject = new GitLab.Project("importPrivateProject", new()
    {
        ImportUrl = "https://gitlab.example.com/repo.git",
        ImportUrlUsername = "user",
        ImportUrlPassword = "pass",
    });
    // Create a project by importing it from a private project and setup the pull mirror
    var importPrivateWithMirror = new GitLab.Project("importPrivateWithMirror", new()
    {
        ImportUrl = "https://gitlab.example.com/repo.git",
        ImportUrlUsername = "user",
        ImportUrlPassword = "pass",
        Mirror = true,
    });
    // Create a project by importing it from a private project and provide credentials in `import_url`
    // NOTE: only use this if you really must, use `import_url_username` and `import_url_password` whenever possible
    //       GitLab API will always return the `import_url` without credentials, therefore you must ignore the `import_url` for changes:
    var importPrivateIndex_projectProject = new GitLab.Project("importPrivateIndex/projectProject", new()
    {
        ImportUrl = "https://user:pass@gitlab.example.com/repo.git",
    });
});

package main
import (
	"github.com/pulumi/pulumi-gitlab/sdk/v6/go/gitlab"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := gitlab.NewProject(ctx, "example", &gitlab.ProjectArgs{
			Description:     pulumi.String("My awesome codebase"),
			VisibilityLevel: pulumi.String("public"),
		})
		if err != nil {
			return err
		}
		// Project with custom push rules
		_, err = gitlab.NewProject(ctx, "example-two", &gitlab.ProjectArgs{
			PushRules: &gitlab.ProjectPushRulesArgs{
				AuthorEmailRegex:     pulumi.String("@example\\.com$"),
				CommitCommitterCheck: pulumi.Bool(true),
				MemberCheck:          pulumi.Bool(true),
				PreventSecrets:       pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		peterParker, err := gitlab.LookupUser(ctx, &gitlab.LookupUserArgs{
			Username: pulumi.StringRef("peter_parker"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = gitlab.NewProject(ctx, "petersRepo", &gitlab.ProjectArgs{
			Description: pulumi.String("This is a description"),
			NamespaceId: pulumi.Int(peterParker.NamespaceId),
		})
		if err != nil {
			return err
		}
		// Fork a project
		_, err = gitlab.NewProject(ctx, "forkProject", &gitlab.ProjectArgs{
			Description:         pulumi.String("This is a fork"),
			ForkedFromProjectId: example.ID(),
		})
		if err != nil {
			return err
		}
		// Fork a project and setup a pull mirror
		_, err = gitlab.NewProject(ctx, "forkIndex/projectProject", &gitlab.ProjectArgs{
			Description:         pulumi.String("This is a fork"),
			ForkedFromProjectId: example.ID(),
			ImportUrl:           example.HttpUrlToRepo,
			Mirror:              pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create a project by importing it from a public project
		_, err = gitlab.NewProject(ctx, "importPublic", &gitlab.ProjectArgs{
			ImportUrl: pulumi.String("https://gitlab.example.com/repo.git"),
		})
		if err != nil {
			return err
		}
		// Create a project by importing it from a public project and setup the pull mirror
		_, err = gitlab.NewProject(ctx, "importPublicWithMirror", &gitlab.ProjectArgs{
			ImportUrl: pulumi.String("https://gitlab.example.com/repo.git"),
			Mirror:    pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create a project by importing it from a private project
		_, err = gitlab.NewProject(ctx, "importPrivateProject", &gitlab.ProjectArgs{
			ImportUrl:         pulumi.String("https://gitlab.example.com/repo.git"),
			ImportUrlUsername: pulumi.String("user"),
			ImportUrlPassword: pulumi.String("pass"),
		})
		if err != nil {
			return err
		}
		// Create a project by importing it from a private project and setup the pull mirror
		_, err = gitlab.NewProject(ctx, "importPrivateWithMirror", &gitlab.ProjectArgs{
			ImportUrl:         pulumi.String("https://gitlab.example.com/repo.git"),
			ImportUrlUsername: pulumi.String("user"),
			ImportUrlPassword: pulumi.String("pass"),
			Mirror:            pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create a project by importing it from a private project and provide credentials in `import_url`
		// NOTE: only use this if you really must, use `import_url_username` and `import_url_password` whenever possible
		//
		//	GitLab API will always return the `import_url` without credentials, therefore you must ignore the `import_url` for changes:
		_, err = gitlab.NewProject(ctx, "importPrivateIndex/projectProject", &gitlab.ProjectArgs{
			ImportUrl: pulumi.String("https://user:pass@gitlab.example.com/repo.git"),
		})
		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.gitlab.Project;
import com.pulumi.gitlab.ProjectArgs;
import com.pulumi.gitlab.inputs.ProjectPushRulesArgs;
import com.pulumi.gitlab.GitlabFunctions;
import com.pulumi.gitlab.inputs.GetUserArgs;
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 example = new Project("example", ProjectArgs.builder()
            .description("My awesome codebase")
            .visibilityLevel("public")
            .build());
        // Project with custom push rules
        var example_two = new Project("example-two", ProjectArgs.builder()
            .pushRules(ProjectPushRulesArgs.builder()
                .authorEmailRegex("@example\\.com$")
                .commitCommitterCheck(true)
                .memberCheck(true)
                .preventSecrets(true)
                .build())
            .build());
        final var peterParker = GitlabFunctions.getUser(GetUserArgs.builder()
            .username("peter_parker")
            .build());
        var petersRepo = new Project("petersRepo", ProjectArgs.builder()
            .description("This is a description")
            .namespaceId(peterParker.applyValue(getUserResult -> getUserResult.namespaceId()))
            .build());
        // Fork a project
        var forkProject = new Project("forkProject", ProjectArgs.builder()
            .description("This is a fork")
            .forkedFromProjectId(example.id())
            .build());
        // Fork a project and setup a pull mirror
        var forkIndex_projectProject = new Project("forkIndex/projectProject", ProjectArgs.builder()
            .description("This is a fork")
            .forkedFromProjectId(example.id())
            .importUrl(example.httpUrlToRepo())
            .mirror(true)
            .build());
        // Create a project by importing it from a public project
        var importPublic = new Project("importPublic", ProjectArgs.builder()
            .importUrl("https://gitlab.example.com/repo.git")
            .build());
        // Create a project by importing it from a public project and setup the pull mirror
        var importPublicWithMirror = new Project("importPublicWithMirror", ProjectArgs.builder()
            .importUrl("https://gitlab.example.com/repo.git")
            .mirror(true)
            .build());
        // Create a project by importing it from a private project
        var importPrivateProject = new Project("importPrivateProject", ProjectArgs.builder()
            .importUrl("https://gitlab.example.com/repo.git")
            .importUrlUsername("user")
            .importUrlPassword("pass")
            .build());
        // Create a project by importing it from a private project and setup the pull mirror
        var importPrivateWithMirror = new Project("importPrivateWithMirror", ProjectArgs.builder()
            .importUrl("https://gitlab.example.com/repo.git")
            .importUrlUsername("user")
            .importUrlPassword("pass")
            .mirror(true)
            .build());
        // Create a project by importing it from a private project and provide credentials in `import_url`
        // NOTE: only use this if you really must, use `import_url_username` and `import_url_password` whenever possible
        //       GitLab API will always return the `import_url` without credentials, therefore you must ignore the `import_url` for changes:
        var importPrivateIndex_projectProject = new Project("importPrivateIndex/projectProject", ProjectArgs.builder()
            .importUrl("https://user:pass@gitlab.example.com/repo.git")
            .build());
    }
}

resources:
  example:
    type: gitlab:Project
    properties:
      description: My awesome codebase
      visibilityLevel: public
  # Project with custom push rules
  example-two:
    type: gitlab:Project
    properties:
      pushRules:
        authorEmailRegex: '@example\.com$'
        commitCommitterCheck: true
        memberCheck: true
        preventSecrets: true
  petersRepo:
    type: gitlab:Project
    properties:
      description: This is a description
      namespaceId: ${peterParker.namespaceId}
  # Fork a project
  forkProject:
    type: gitlab:Project
    properties:
      description: This is a fork
      forkedFromProjectId: ${example.id}
  # Fork a project and setup a pull mirror
  forkIndex/projectProject:
    type: gitlab:Project
    properties:
      description: This is a fork
      forkedFromProjectId: ${example.id}
      importUrl: ${example.httpUrlToRepo}
      mirror: true
  # Create a project by importing it from a public project
  importPublic:
    type: gitlab:Project
    properties:
      importUrl: https://gitlab.example.com/repo.git
  # Create a project by importing it from a public project and setup the pull mirror
  importPublicWithMirror:
    type: gitlab:Project
    properties:
      importUrl: https://gitlab.example.com/repo.git
      mirror: true
  # Create a project by importing it from a private project
  importPrivateProject:
    type: gitlab:Project
    properties:
      importUrl: https://gitlab.example.com/repo.git
      importUrlUsername: user
      importUrlPassword: pass
  # Create a project by importing it from a private project and setup the pull mirror
  importPrivateWithMirror:
    type: gitlab:Project
    properties:
      importUrl: https://gitlab.example.com/repo.git
      importUrlUsername: user
      importUrlPassword: pass
      mirror: true
  # Create a project by importing it from a private project and provide credentials in `import_url`
  # NOTE: only use this if you really must, use `import_url_username` and `import_url_password` whenever possible
  #       GitLab API will always return the `import_url` without credentials, therefore you must ignore the `import_url` for changes:
  importPrivateIndex/projectProject:
    type: gitlab:Project
    properties:
      importUrl: https://user:pass@gitlab.example.com/repo.git
variables:
  peterParker:
    fn::invoke:
      Function: gitlab:getUser
      Arguments:
        username: peter_parker

$ pulumi import gitlab:index/project:Project You can import a project state using `<resource> <id>`. The

$ pulumi import gitlab:index/project:Project example richardc/example