artifactory.ScopedToken

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

//## Create a new Artifactory scoped token for an existing user
const scopedToken = new artifactory.ScopedToken("scoped_token", {username: "existing-user"});
//## **Note:** This assumes that the user `existing-user` has already been created in Artifactory by different means, i.e. manually or in a separate pulumi up.
//## Create a new Artifactory user and scoped token
const newUser = new artifactory.User("new_user", {
    name: "new_user",
    email: "new_user@somewhere.com",
    groups: ["readers"],
});
const scopedTokenUser = new artifactory.ScopedToken("scoped_token_user", {username: newUser.name});
//## Creates a new token for groups
const scopedTokenGroup = new artifactory.ScopedToken("scoped_token_group", {scopes: ["applied-permissions/groups:readers"]});
//## Create token with expiry
const scopedTokenNoExpiry = new artifactory.ScopedToken("scoped_token_no_expiry", {
    username: "existing-user",
    expiresIn: 7200,
});
//## Creates a refreshable token
const scopedTokenRefreshable = new artifactory.ScopedToken("scoped_token_refreshable", {
    username: "existing-user",
    refreshable: true,
});
//## Creates an administrator token
const admin = new artifactory.ScopedToken("admin", {
    username: "admin-user",
    scopes: ["applied-permissions/admin"],
});
//## Creates a token with an audience
const audience = new artifactory.ScopedToken("audience", {
    username: "admin-user",
    scopes: ["applied-permissions/admin"],
    audiences: ["jfrt@*"],
});

import pulumi
import pulumi_artifactory as artifactory

### Create a new Artifactory scoped token for an existing user
scoped_token = artifactory.ScopedToken("scoped_token", username="existing-user")
### **Note:** This assumes that the user `existing-user` has already been created in Artifactory by different means, i.e. manually or in a separate pulumi up.
### Create a new Artifactory user and scoped token
new_user = artifactory.User("new_user",
    name="new_user",
    email="new_user@somewhere.com",
    groups=["readers"])
scoped_token_user = artifactory.ScopedToken("scoped_token_user", username=new_user.name)
### Creates a new token for groups
scoped_token_group = artifactory.ScopedToken("scoped_token_group", scopes=["applied-permissions/groups:readers"])
### Create token with expiry
scoped_token_no_expiry = artifactory.ScopedToken("scoped_token_no_expiry",
    username="existing-user",
    expires_in=7200)
### Creates a refreshable token
scoped_token_refreshable = artifactory.ScopedToken("scoped_token_refreshable",
    username="existing-user",
    refreshable=True)
### Creates an administrator token
admin = artifactory.ScopedToken("admin",
    username="admin-user",
    scopes=["applied-permissions/admin"])
### Creates a token with an audience
audience = artifactory.ScopedToken("audience",
    username="admin-user",
    scopes=["applied-permissions/admin"],
    audiences=["jfrt@*"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ## Create a new Artifactory scoped token for an existing user
		_, err := artifactory.NewScopedToken(ctx, "scoped_token", &artifactory.ScopedTokenArgs{
			Username: pulumi.String("existing-user"),
		})
		if err != nil {
			return err
		}
		// ## Create a new Artifactory user and scoped token
		newUser, err := artifactory.NewUser(ctx, "new_user", &artifactory.UserArgs{
			Name:  pulumi.String("new_user"),
			Email: pulumi.String("new_user@somewhere.com"),
			Groups: pulumi.StringArray{
				pulumi.String("readers"),
			},
		})
		if err != nil {
			return err
		}
		_, err = artifactory.NewScopedToken(ctx, "scoped_token_user", &artifactory.ScopedTokenArgs{
			Username: newUser.Name,
		})
		if err != nil {
			return err
		}
		// ## Creates a new token for groups
		_, err = artifactory.NewScopedToken(ctx, "scoped_token_group", &artifactory.ScopedTokenArgs{
			Scopes: pulumi.StringArray{
				pulumi.String("applied-permissions/groups:readers"),
			},
		})
		if err != nil {
			return err
		}
		// ## Create token with expiry
		_, err = artifactory.NewScopedToken(ctx, "scoped_token_no_expiry", &artifactory.ScopedTokenArgs{
			Username:  pulumi.String("existing-user"),
			ExpiresIn: pulumi.Int(7200),
		})
		if err != nil {
			return err
		}
		// ## Creates a refreshable token
		_, err = artifactory.NewScopedToken(ctx, "scoped_token_refreshable", &artifactory.ScopedTokenArgs{
			Username:    pulumi.String("existing-user"),
			Refreshable: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// ## Creates an administrator token
		_, err = artifactory.NewScopedToken(ctx, "admin", &artifactory.ScopedTokenArgs{
			Username: pulumi.String("admin-user"),
			Scopes: pulumi.StringArray{
				pulumi.String("applied-permissions/admin"),
			},
		})
		if err != nil {
			return err
		}
		// ## Creates a token with an audience
		_, err = artifactory.NewScopedToken(ctx, "audience", &artifactory.ScopedTokenArgs{
			Username: pulumi.String("admin-user"),
			Scopes: pulumi.StringArray{
				pulumi.String("applied-permissions/admin"),
			},
			Audiences: pulumi.StringArray{
				pulumi.String("jfrt@*"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    //## Create a new Artifactory scoped token for an existing user
    var scopedToken = new Artifactory.ScopedToken("scoped_token", new()
    {
        Username = "existing-user",
    });

    //## **Note:** This assumes that the user `existing-user` has already been created in Artifactory by different means, i.e. manually or in a separate pulumi up.
    //## Create a new Artifactory user and scoped token
    var newUser = new Artifactory.User("new_user", new()
    {
        Name = "new_user",
        Email = "new_user@somewhere.com",
        Groups = new[]
        {
            "readers",
        },
    });

    var scopedTokenUser = new Artifactory.ScopedToken("scoped_token_user", new()
    {
        Username = newUser.Name,
    });

    //## Creates a new token for groups
    var scopedTokenGroup = new Artifactory.ScopedToken("scoped_token_group", new()
    {
        Scopes = new[]
        {
            "applied-permissions/groups:readers",
        },
    });

    //## Create token with expiry
    var scopedTokenNoExpiry = new Artifactory.ScopedToken("scoped_token_no_expiry", new()
    {
        Username = "existing-user",
        ExpiresIn = 7200,
    });

    //## Creates a refreshable token
    var scopedTokenRefreshable = new Artifactory.ScopedToken("scoped_token_refreshable", new()
    {
        Username = "existing-user",
        Refreshable = true,
    });

    //## Creates an administrator token
    var admin = new Artifactory.ScopedToken("admin", new()
    {
        Username = "admin-user",
        Scopes = new[]
        {
            "applied-permissions/admin",
        },
    });

    //## Creates a token with an audience
    var audience = new Artifactory.ScopedToken("audience", new()
    {
        Username = "admin-user",
        Scopes = new[]
        {
            "applied-permissions/admin",
        },
        Audiences = new[]
        {
            "jfrt@*",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.artifactory.ScopedToken;
import com.pulumi.artifactory.ScopedTokenArgs;
import com.pulumi.artifactory.User;
import com.pulumi.artifactory.UserArgs;
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 new Artifactory scoped token for an existing user
        var scopedToken = new ScopedToken("scopedToken", ScopedTokenArgs.builder()
            .username("existing-user")
            .build());

        //## **Note:** This assumes that the user `existing-user` has already been created in Artifactory by different means, i.e. manually or in a separate pulumi up.
        //## Create a new Artifactory user and scoped token
        var newUser = new User("newUser", UserArgs.builder()
            .name("new_user")
            .email("new_user@somewhere.com")
            .groups("readers")
            .build());

        var scopedTokenUser = new ScopedToken("scopedTokenUser", ScopedTokenArgs.builder()
            .username(newUser.name())
            .build());

        //## Creates a new token for groups
        var scopedTokenGroup = new ScopedToken("scopedTokenGroup", ScopedTokenArgs.builder()
            .scopes("applied-permissions/groups:readers")
            .build());

        //## Create token with expiry
        var scopedTokenNoExpiry = new ScopedToken("scopedTokenNoExpiry", ScopedTokenArgs.builder()
            .username("existing-user")
            .expiresIn(7200)
            .build());

        //## Creates a refreshable token
        var scopedTokenRefreshable = new ScopedToken("scopedTokenRefreshable", ScopedTokenArgs.builder()
            .username("existing-user")
            .refreshable(true)
            .build());

        //## Creates an administrator token
        var admin = new ScopedToken("admin", ScopedTokenArgs.builder()
            .username("admin-user")
            .scopes("applied-permissions/admin")
            .build());

        //## Creates a token with an audience
        var audience = new ScopedToken("audience", ScopedTokenArgs.builder()
            .username("admin-user")
            .scopes("applied-permissions/admin")
            .audiences("jfrt@*")
            .build());

    }
}

resources:
  ### Create a new Artifactory scoped token for an existing user
  scopedToken: ### **Note:** This assumes that the user `existing-user` has already been created in Artifactory by different means, i.e. manually or in a separate pulumi up.
    type: artifactory:ScopedToken
    name: scoped_token
    properties:
      username: existing-user
  ### Create a new Artifactory user and scoped token
  newUser:
    type: artifactory:User
    name: new_user
    properties:
      name: new_user
      email: new_user@somewhere.com
      groups:
        - readers
  scopedTokenUser:
    type: artifactory:ScopedToken
    name: scoped_token_user
    properties:
      username: ${newUser.name}
  ### Creates a new token for groups
  scopedTokenGroup:
    type: artifactory:ScopedToken
    name: scoped_token_group
    properties:
      scopes:
        - applied-permissions/groups:readers
  ### Create token with expiry
  scopedTokenNoExpiry:
    type: artifactory:ScopedToken
    name: scoped_token_no_expiry
    properties:
      username: existing-user
      expiresIn: 7200 # in seconds
  ### Creates a refreshable token
  scopedTokenRefreshable:
    type: artifactory:ScopedToken
    name: scoped_token_refreshable
    properties:
      username: existing-user
      refreshable: true
  ### Creates an administrator token
  admin:
    type: artifactory:ScopedToken
    properties:
      username: admin-user
      scopes:
        - applied-permissions/admin
  ### Creates a token with an audience
  audience:
    type: artifactory:ScopedToken
    properties:
      username: admin-user
      scopes:
        - applied-permissions/admin
      audiences:
        - jfrt@*

var scopedTokenResource = new Artifactory.ScopedToken("scopedTokenResource", new()
{
    Audiences = new[]
    {
        "string",
    },
    Description = "string",
    ExpiresIn = 0,
    GrantType = "string",
    IgnoreMissingTokenWarning = false,
    IncludeReferenceToken = false,
    ProjectKey = "string",
    Refreshable = false,
    Scopes = new[]
    {
        "string",
    },
    Username = "string",
});

example, err := artifactory.NewScopedToken(ctx, "scopedTokenResource", &artifactory.ScopedTokenArgs{
	Audiences: pulumi.StringArray{
		pulumi.String("string"),
	},
	Description:               pulumi.String("string"),
	ExpiresIn:                 pulumi.Int(0),
	GrantType:                 pulumi.String("string"),
	IgnoreMissingTokenWarning: pulumi.Bool(false),
	IncludeReferenceToken:     pulumi.Bool(false),
	ProjectKey:                pulumi.String("string"),
	Refreshable:               pulumi.Bool(false),
	Scopes: pulumi.StringArray{
		pulumi.String("string"),
	},
	Username: pulumi.String("string"),
})

var scopedTokenResource = new ScopedToken("scopedTokenResource", ScopedTokenArgs.builder()
    .audiences("string")
    .description("string")
    .expiresIn(0)
    .grantType("string")
    .ignoreMissingTokenWarning(false)
    .includeReferenceToken(false)
    .projectKey("string")
    .refreshable(false)
    .scopes("string")
    .username("string")
    .build());

scoped_token_resource = artifactory.ScopedToken("scopedTokenResource",
    audiences=["string"],
    description="string",
    expires_in=0,
    grant_type="string",
    ignore_missing_token_warning=False,
    include_reference_token=False,
    project_key="string",
    refreshable=False,
    scopes=["string"],
    username="string")

const scopedTokenResource = new artifactory.ScopedToken("scopedTokenResource", {
    audiences: ["string"],
    description: "string",
    expiresIn: 0,
    grantType: "string",
    ignoreMissingTokenWarning: false,
    includeReferenceToken: false,
    projectKey: "string",
    refreshable: false,
    scopes: ["string"],
    username: "string",
});

type: artifactory:ScopedToken
properties:
    audiences:
        - string
    description: string
    expiresIn: 0
    grantType: string
    ignoreMissingTokenWarning: false
    includeReferenceToken: false
    projectKey: string
    refreshable: false
    scopes:
        - string
    username: string