Package 'paws.developer.tools'

Description

Cloud9

Cloud9 is a collection of tools that you can use to code, build, run, test, debug, and release software in the cloud.

For more information about Cloud9, see the Cloud9 User Guide.

Cloud9 supports these operations:

• create_environment_ec2: Creates an Cloud9 development environment, launches an Amazon EC2 instance, and then connects from the instance to the environment.

• create_environment_membership: Adds an environment member to an environment.

• delete_environment: Deletes an environment. If an Amazon EC2 instance is connected to the environment, also terminates the instance.

• delete_environment_membership: Deletes an environment member from an environment.

• describe_environment_memberships: Gets information about environment members for an environment.

• describe_environments: Gets information about environments.

• describe_environment_status: Gets status information for an environment.

• list_environments: Gets a list of environment identifiers.

• list_tags_for_resource: Gets the tags for an environment.

• tag_resource: Adds tags to an environment.

• untag_resource: Removes tags from an environment.

• update_environment: Changes the settings of an existing environment.

• update_environment_membership: Changes the settings of an existing environment member for an environment.

Usage

cloud9(config = list(), credentials = list(), endpoint = NULL, region = NULL)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- cloud9(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- cloud9()
# 
svc$create_environment_ec2(
  name = "my-demo-environment",
  automaticStopTimeMinutes = 60L,
  description = "This is my demonstration environment.",
  imageId = "amazonlinux-2023-x86_64",
  instanceType = "t2.micro",
  ownerArn = "arn:aws:iam::123456789012:user/MyDemoUser",
  subnetId = "subnet-6300cd1b"
)

## End(Not run)

Description

For more information about Amazon Web Services Cloud Control API, see the Amazon Web Services Cloud Control API User Guide.

Usage

cloudcontrolapi(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- cloudcontrolapi(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- cloudcontrolapi()
svc$cancel_resource_request(
  Foo = 123
)

## End(Not run)

Description

CodeArtifact is a fully managed artifact repository compatible with language-native package managers and build tools such as npm, Apache Maven, pip, and dotnet. You can use CodeArtifact to share packages with development teams and pull packages. Packages can be pulled from both public and CodeArtifact repositories. You can also create an upstream relationship between a CodeArtifact repository and another repository, which effectively merges their contents from the point of view of a package manager client.

CodeArtifact concepts

• Repository: A CodeArtifact repository contains a set of package versions, each of which maps to a set of assets, or files. Repositories are polyglot, so a single repository can contain packages of any supported type. Each repository exposes endpoints for fetching and publishing packages using tools such as the npm CLI or the Maven CLI ( mvn ). For a list of supported package managers, see the CodeArtifact User Guide.

• Domain: Repositories are aggregated into a higher-level entity known as a domain. All package assets and metadata are stored in the domain, but are consumed through repositories. A given package asset, such as a Maven JAR file, is stored once per domain, no matter how many repositories it's present in. All of the assets and metadata in a domain are encrypted with the same customer master key (CMK) stored in Key Management Service (KMS).

  Each repository is a member of a single domain and can't be moved to a different domain.

  The domain allows organizational policy to be applied across multiple repositories, such as which accounts can access repositories in the domain, and which public repositories can be used as sources of packages.

  Although an organization can have multiple domains, we recommend a single production domain that contains all published artifacts so that teams can find and share packages across their organization.

• Package: A package is a bundle of software and the metadata required to resolve dependencies and install the software. CodeArtifact supports npm, PyPI, Maven, NuGet, Swift, Ruby, Cargo, and generic package formats. For more information about the supported package formats and how to use CodeArtifact with them, see the CodeArtifact User Guide.

  In CodeArtifact, a package consists of:

  • A name (for example, webpack is the name of a popular npm package)

  • An optional namespace (for example, ⁠@types⁠ in ⁠@types/node⁠)

  • A set of versions (for example, ⁠1.0.0⁠, ⁠1.0.1⁠, ⁠1.0.2⁠, etc.)

  • Package-level metadata (for example, npm tags)

• Package group: A group of packages that match a specified definition. Package groups can be used to apply configuration to multiple packages that match a defined pattern using package format, package namespace, and package name. You can use package groups to more conveniently configure package origin controls for multiple packages. Package origin controls are used to block or allow ingestion or publishing of new package versions, which protects users from malicious actions known as dependency substitution attacks.

• Package version: A version of a package, such as ⁠@types/node 12.6.9⁠. The version number format and semantics vary for different package formats. For example, npm package versions must conform to the Semantic Versioning specification. In CodeArtifact, a package version consists of the version identifier, metadata at the package version level, and a set of assets.

• Upstream repository: One repository is upstream of another when the package versions in it can be accessed from the repository endpoint of the downstream repository, effectively merging the contents of the two repositories from the point of view of a client. CodeArtifact allows creating an upstream relationship between two repositories.

• Asset: An individual file stored in CodeArtifact associated with a package version, such as an npm .tgz file or Maven POM and JAR files.

CodeArtifact supported API operations

• associate_external_connection: Adds an existing external connection to a repository.

• copy_package_versions: Copies package versions from one repository to another repository in the same domain.

• create_domain: Creates a domain.

• create_package_group: Creates a package group.

• create_repository: Creates a CodeArtifact repository in a domain.

• delete_domain: Deletes a domain. You cannot delete a domain that contains repositories.

• delete_domain_permissions_policy: Deletes the resource policy that is set on a domain.

• delete_package: Deletes a package and all associated package versions.

• delete_package_group: Deletes a package group. Does not delete packages or package versions that are associated with a package group.

• delete_package_versions: Deletes versions of a package. After a package has been deleted, it can be republished, but its assets and metadata cannot be restored because they have been permanently removed from storage.

• delete_repository: Deletes a repository.

• delete_repository_permissions_policy: Deletes the resource policy that is set on a repository.

• describe_domain: Returns a DomainDescription object that contains information about the requested domain.

• describe_package: Returns a PackageDescription object that contains details about a package.

• describe_package_group: Returns a PackageGroup object that contains details about a package group.

• describe_package_version: Returns a PackageVersionDescription object that contains details about a package version.

• describe_repository: Returns a RepositoryDescription object that contains detailed information about the requested repository.

• dispose_package_versions: Disposes versions of a package. A package version with the status Disposed cannot be restored because they have been permanently removed from storage.

• disassociate_external_connection: Removes an existing external connection from a repository.

• get_associated_package_group: Returns the most closely associated package group to the specified package.

• get_authorization_token: Generates a temporary authorization token for accessing repositories in the domain. The token expires the authorization period has passed. The default authorization period is 12 hours and can be customized to any length with a maximum of 12 hours.

• get_domain_permissions_policy: Returns the policy of a resource that is attached to the specified domain.

• get_package_version_asset: Returns the contents of an asset that is in a package version.

• get_package_version_readme: Gets the readme file or descriptive text for a package version.

• get_repository_endpoint: Returns the endpoint of a repository for a specific package format. A repository has one endpoint for each package format:

  • cargo

  • generic

  • maven

  • npm

  • nuget

  • pypi

  • ruby

  • swift

• get_repository_permissions_policy: Returns the resource policy that is set on a repository.

• list_allowed_repositories_for_group: Lists the allowed repositories for a package group that has origin configuration set to ALLOW_SPECIFIC_REPOSITORIES.

• list_associated_packages: Returns a list of packages associated with the requested package group.

• list_domains: Returns a list of DomainSummary objects. Each returned DomainSummary object contains information about a domain.

• list_packages: Lists the packages in a repository.

• list_package_groups: Returns a list of package groups in the requested domain.

• list_package_version_assets: Lists the assets for a given package version.

• list_package_version_dependencies: Returns a list of the direct dependencies for a package version.

• list_package_versions: Returns a list of package versions for a specified package in a repository.

• list_repositories: Returns a list of repositories owned by the Amazon Web Services account that called this method.

• list_repositories_in_domain: Returns a list of the repositories in a domain.

• list_sub_package_groups: Returns a list of direct children of the specified package group.

• publish_package_version: Creates a new package version containing one or more assets.

• put_domain_permissions_policy: Attaches a resource policy to a domain.

• put_package_origin_configuration: Sets the package origin configuration for a package, which determine how new versions of the package can be added to a specific repository.

• put_repository_permissions_policy: Sets the resource policy on a repository that specifies permissions to access it.

• update_package_group: Updates a package group. This API cannot be used to update a package group's origin configuration or pattern.

• update_package_group_origin_configuration: Updates the package origin configuration for a package group.

• update_package_versions_status: Updates the status of one or more versions of a package.

• update_repository: Updates the properties of a repository.

Usage

codeartifact(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codeartifact(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codeartifact()
svc$associate_external_connection(
  Foo = 123
)

## End(Not run)

Description

CodeBuild

CodeBuild is a fully managed build service in the cloud. CodeBuild compiles your source code, runs unit tests, and produces artifacts that are ready to deploy. CodeBuild eliminates the need to provision, manage, and scale your own build servers. It provides prepackaged build environments for the most popular programming languages and build tools, such as Apache Maven, Gradle, and more. You can also fully customize build environments in CodeBuild to use your own build tools. CodeBuild scales automatically to meet peak build requests. You pay only for the build time you consume. For more information about CodeBuild, see the CodeBuild User Guide.

Usage

codebuild(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codebuild(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codebuild()
svc$batch_delete_builds(
  Foo = 123
)

## End(Not run)

Description

Welcome to the Amazon CodeCatalyst API reference. This reference provides descriptions of operations and data types for Amazon CodeCatalyst. You can use the Amazon CodeCatalyst API to work with the following objects.

Spaces, by calling the following:

• delete_space, which deletes a space.

• get_space, which returns information about a space.

• get_subscription, which returns information about the Amazon Web Services account used for billing purposes and the billing plan for the space.

• list_spaces, which retrieves a list of spaces.

• update_space, which changes one or more values for a space.

Projects, by calling the following:

• create_project which creates a project in a specified space.

• get_project, which returns information about a project.

• list_projects, which retrieves a list of projects in a space.

Users, by calling the following:

• get_user_details, which returns information about a user in Amazon CodeCatalyst.

Source repositories, by calling the following:

• create_source_repository, which creates an empty Git-based source repository in a specified project.

• create_source_repository_branch, which creates a branch in a specified repository where you can work on code.

• delete_source_repository, which deletes a source repository.

• get_source_repository, which returns information about a source repository.

• get_source_repository_clone_urls, which returns information about the URLs that can be used with a Git client to clone a source repository.

• list_source_repositories, which retrieves a list of source repositories in a project.

• list_source_repository_branches, which retrieves a list of branches in a source repository.

Dev Environments and the Amazon Web Services Toolkits, by calling the following:

• create_dev_environment, which creates a Dev Environment, where you can quickly work on the code stored in the source repositories of your project.

• delete_dev_environment, which deletes a Dev Environment.

• get_dev_environment, which returns information about a Dev Environment.

• list_dev_environments, which retrieves a list of Dev Environments in a project.

• list_dev_environment_sessions, which retrieves a list of active Dev Environment sessions in a project.

• start_dev_environment, which starts a specified Dev Environment and puts it into an active state.

• start_dev_environment_session, which starts a session to a specified Dev Environment.

• stop_dev_environment, which stops a specified Dev Environment and puts it into an stopped state.

• stop_dev_environment_session, which stops a session for a specified Dev Environment.

• update_dev_environment, which changes one or more values for a Dev Environment.

Workflows, by calling the following:

• get_workflow, which returns information about a workflow.

• get_workflow_run, which returns information about a specified run of a workflow.

• list_workflow_runs, which retrieves a list of runs of a specified workflow.

• list_workflows, which retrieves a list of workflows in a specified project.

• start_workflow_run, which starts a run of a specified workflow.

Security, activity, and resource management in Amazon CodeCatalyst, by calling the following:

• create_access_token, which creates a personal access token (PAT) for the current user.

• delete_access_token, which deletes a specified personal access token (PAT).

• list_access_tokens, which lists all personal access tokens (PATs) associated with a user.

• list_event_logs, which retrieves a list of events that occurred during a specified time period in a space.

• verify_session, which verifies whether the calling user has a valid Amazon CodeCatalyst login and session.

If you are using the Amazon CodeCatalyst APIs with an SDK or the CLI, you must configure your computer to work with Amazon CodeCatalyst and single sign-on (SSO). For more information, see Setting up to use the CLI with Amazon CodeCatalyst and the SSO documentation for your SDK.

Usage

codecatalyst(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codecatalyst(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codecatalyst()
svc$create_access_token(
  Foo = 123
)

## End(Not run)

Description

CodeCommit

This is the CodeCommit API Reference. This reference provides descriptions of the operations and data types for CodeCommit API along with usage examples.

You can use the CodeCommit API to work with the following objects:

Repositories, by calling the following:

• batch_get_repositories, which returns information about one or more repositories associated with your Amazon Web Services account.

• create_repository, which creates an CodeCommit repository.

• delete_repository, which deletes an CodeCommit repository.

• get_repository, which returns information about a specified repository.

• list_repositories, which lists all CodeCommit repositories associated with your Amazon Web Services account.

• update_repository_description, which sets or updates the description of the repository.

• update_repository_encryption_key, which updates the Key Management Service encryption key used to encrypt and decrypt a repository.

• update_repository_name, which changes the name of the repository. If you change the name of a repository, no other users of that repository can access it until you send them the new HTTPS or SSH URL to use.

Branches, by calling the following:

• create_branch, which creates a branch in a specified repository.

• delete_branch, which deletes the specified branch in a repository unless it is the default branch.

• get_branch, which returns information about a specified branch.

• list_branches, which lists all branches for a specified repository.

• update_default_branch, which changes the default branch for a repository.

Files, by calling the following:

• delete_file, which deletes the content of a specified file from a specified branch.

• get_blob, which returns the base-64 encoded content of an individual Git blob object in a repository.

• get_file, which returns the base-64 encoded content of a specified file.

• get_folder, which returns the contents of a specified folder or directory.

• list_file_commit_history, which retrieves a list of commits and changes to a specified file.

• put_file, which adds or modifies a single file in a specified repository and branch.

Commits, by calling the following:

• batch_get_commits, which returns information about one or more commits in a repository.

• create_commit, which creates a commit for changes to a repository.

• get_commit, which returns information about a commit, including commit messages and author and committer information.

• get_differences, which returns information about the differences in a valid commit specifier (such as a branch, tag, HEAD, commit ID, or other fully qualified reference).

Merges, by calling the following:

• batch_describe_merge_conflicts, which returns information about conflicts in a merge between commits in a repository.

• create_unreferenced_merge_commit, which creates an unreferenced commit between two branches or commits for the purpose of comparing them and identifying any potential conflicts.

• describe_merge_conflicts, which returns information about merge conflicts between the base, source, and destination versions of a file in a potential merge.

• get_merge_commit, which returns information about the merge between a source and destination commit.

• get_merge_conflicts, which returns information about merge conflicts between the source and destination branch in a pull request.

• get_merge_options, which returns information about the available merge options between two branches or commit specifiers.

• merge_branches_by_fast_forward, which merges two branches using the fast-forward merge option.

• merge_branches_by_squash, which merges two branches using the squash merge option.

• merge_branches_by_three_way, which merges two branches using the three-way merge option.

Pull requests, by calling the following:

• create_pull_request, which creates a pull request in a specified repository.

• create_pull_request_approval_rule, which creates an approval rule for a specified pull request.

• delete_pull_request_approval_rule, which deletes an approval rule for a specified pull request.

• describe_pull_request_events, which returns information about one or more pull request events.

• evaluate_pull_request_approval_rules, which evaluates whether a pull request has met all the conditions specified in its associated approval rules.

• get_comments_for_pull_request, which returns information about comments on a specified pull request.

• get_pull_request, which returns information about a specified pull request.

• get_pull_request_approval_states, which returns information about the approval states for a specified pull request.

• get_pull_request_override_state, which returns information about whether approval rules have been set aside (overriden) for a pull request, and if so, the Amazon Resource Name (ARN) of the user or identity that overrode the rules and their requirements for the pull request.

• list_pull_requests, which lists all pull requests for a repository.

• merge_pull_request_by_fast_forward, which merges the source destination branch of a pull request into the specified destination branch for that pull request using the fast-forward merge option.

• merge_pull_request_by_squash, which merges the source destination branch of a pull request into the specified destination branch for that pull request using the squash merge option.

• merge_pull_request_by_three_way, which merges the source destination branch of a pull request into the specified destination branch for that pull request using the three-way merge option.

• override_pull_request_approval_rules, which sets aside all approval rule requirements for a pull request.

• post_comment_for_pull_request, which posts a comment to a pull request at the specified line, file, or request.

• update_pull_request_approval_rule_content, which updates the structure of an approval rule for a pull request.

• update_pull_request_approval_state, which updates the state of an approval on a pull request.

• update_pull_request_description, which updates the description of a pull request.

• update_pull_request_status, which updates the status of a pull request.

• update_pull_request_title, which updates the title of a pull request.

Approval rule templates, by calling the following:

• associate_approval_rule_template_with_repository, which associates a template with a specified repository. After the template is associated with a repository, CodeCommit creates approval rules that match the template conditions on every pull request created in the specified repository.

• batch_associate_approval_rule_template_with_repositories, which associates a template with one or more specified repositories. After the template is associated with a repository, CodeCommit creates approval rules that match the template conditions on every pull request created in the specified repositories.

• batch_disassociate_approval_rule_template_from_repositories, which removes the association between a template and specified repositories so that approval rules based on the template are not automatically created when pull requests are created in those repositories.

• create_approval_rule_template, which creates a template for approval rules that can then be associated with one or more repositories in your Amazon Web Services account.

• delete_approval_rule_template, which deletes the specified template. It does not remove approval rules on pull requests already created with the template.

• disassociate_approval_rule_template_from_repository, which removes the association between a template and a repository so that approval rules based on the template are not automatically created when pull requests are created in the specified repository.

• get_approval_rule_template, which returns information about an approval rule template.

• list_approval_rule_templates, which lists all approval rule templates in the Amazon Web Services Region in your Amazon Web Services account.

• list_associated_approval_rule_templates_for_repository, which lists all approval rule templates that are associated with a specified repository.

• list_repositories_for_approval_rule_template, which lists all repositories associated with the specified approval rule template.

• update_approval_rule_template_description, which updates the description of an approval rule template.

• update_approval_rule_template_name, which updates the name of an approval rule template.

• update_approval_rule_template_content, which updates the content of an approval rule template.

Comments in a repository, by calling the following:

• delete_comment_content, which deletes the content of a comment on a commit in a repository.

• get_comment, which returns information about a comment on a commit.

• get_comment_reactions, which returns information about emoji reactions to comments.

• get_comments_for_compared_commit, which returns information about comments on the comparison between two commit specifiers in a repository.

• post_comment_for_compared_commit, which creates a comment on the comparison between two commit specifiers in a repository.

• post_comment_reply, which creates a reply to a comment.

• put_comment_reaction, which creates or updates an emoji reaction to a comment.

• update_comment, which updates the content of a comment on a commit in a repository.

Tags used to tag resources in CodeCommit (not Git tags), by calling the following:

• list_tags_for_resource, which gets information about Amazon Web Servicestags for a specified Amazon Resource Name (ARN) in CodeCommit.

• tag_resource, which adds or updates tags for a resource in CodeCommit.

• untag_resource, which removes tags for a resource in CodeCommit.

Triggers, by calling the following:

• get_repository_triggers, which returns information about triggers configured for a repository.

• put_repository_triggers, which replaces all triggers for a repository and can be used to create or delete triggers.

• test_repository_triggers, which tests the functionality of a repository trigger by sending data to the trigger target.

For information about how to use CodeCommit, see the CodeCommit User Guide.

Usage

codecommit(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codecommit(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codecommit()
svc$associate_approval_rule_template_with_repository(
  Foo = 123
)

## End(Not run)

Description

CodeDeploy is a deployment service that automates application deployments to Amazon EC2 instances, on-premises instances running in your own facility, serverless Lambda functions, or applications in an Amazon ECS service.

You can deploy a nearly unlimited variety of application content, such as an updated Lambda function, updated applications in an Amazon ECS service, code, web and configuration files, executables, packages, scripts, multimedia files, and so on. CodeDeploy can deploy application content stored in Amazon S3 buckets, GitHub repositories, or Bitbucket repositories. You do not need to make changes to your existing code before you can use CodeDeploy.

CodeDeploy makes it easier for you to rapidly release new features, helps you avoid downtime during application deployment, and handles the complexity of updating your applications, without many of the risks associated with error-prone manual deployments.

CodeDeploy Components

Use the information in this guide to help you work with the following CodeDeploy components:

• Application: A name that uniquely identifies the application you want to deploy. CodeDeploy uses this name, which functions as a container, to ensure the correct combination of revision, deployment configuration, and deployment group are referenced during a deployment.

• Deployment group: A set of individual instances, CodeDeploy Lambda deployment configuration settings, or an Amazon ECS service and network details. A Lambda deployment group specifies how to route traffic to a new version of a Lambda function. An Amazon ECS deployment group specifies the service created in Amazon ECS to deploy, a load balancer, and a listener to reroute production traffic to an updated containerized application. An Amazon EC2/On-premises deployment group contains individually tagged instances, Amazon EC2 instances in Amazon EC2 Auto Scaling groups, or both. All deployment groups can specify optional trigger, alarm, and rollback settings.

• Deployment configuration: A set of deployment rules and deployment success and failure conditions used by CodeDeploy during a deployment.

• Deployment: The process and the components used when updating a Lambda function, a containerized application in an Amazon ECS service, or of installing content on one or more instances.

• Application revisions: For an Lambda deployment, this is an AppSpec file that specifies the Lambda function to be updated and one or more functions to validate deployment lifecycle events. For an Amazon ECS deployment, this is an AppSpec file that specifies the Amazon ECS task definition, container, and port where production traffic is rerouted. For an EC2/On-premises deployment, this is an archive file that contains source content—source code, webpages, executable files, and deployment scripts—along with an AppSpec file. Revisions are stored in Amazon S3 buckets or GitHub repositories. For Amazon S3, a revision is uniquely identified by its Amazon S3 object key and its ETag, version, or both. For GitHub, a revision is uniquely identified by its commit ID.

This guide also contains information to help you get details about the instances in your deployments, to make on-premises instances available for CodeDeploy deployments, to get details about a Lambda function deployment, and to get details about Amazon ECS service deployments.

CodeDeploy Information Resources

• CodeDeploy User Guide

• CodeDeploy API Reference Guide

• CLI Reference for CodeDeploy

• CodeDeploy Developer Forum

Usage

codedeploy(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codedeploy(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codedeploy()
svc$add_tags_to_on_premises_instances(
  Foo = 123
)

## End(Not run)

Description

This section provides documentation for the Amazon CodeGuru Profiler API operations.

Amazon CodeGuru Profiler collects runtime performance data from your live applications, and provides recommendations that can help you fine-tune your application performance. Using machine learning algorithms, CodeGuru Profiler can help you find your most expensive lines of code and suggest ways you can improve efficiency and remove CPU bottlenecks.

Amazon CodeGuru Profiler provides different visualizations of profiling data to help you identify what code is running on the CPU, see how much time is consumed, and suggest ways to reduce CPU utilization.

Amazon CodeGuru Profiler currently supports applications written in all Java virtual machine (JVM) languages and Python. While CodeGuru Profiler supports both visualizations and recommendations for applications written in Java, it can also generate visualizations and a subset of recommendations for applications written in other JVM languages and Python.

For more information, see What is Amazon CodeGuru Profiler in the Amazon CodeGuru Profiler User Guide.

Usage

codeguruprofiler(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codeguruprofiler(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codeguruprofiler()
svc$add_notification_channels(
  Foo = 123
)

## End(Not run)

Description

This section provides documentation for the Amazon CodeGuru Reviewer API operations. CodeGuru Reviewer is a service that uses program analysis and machine learning to detect potential defects that are difficult for developers to find and recommends fixes in your Java and Python code.

By proactively detecting and providing recommendations for addressing code defects and implementing best practices, CodeGuru Reviewer improves the overall quality and maintainability of your code base during the code review stage. For more information about CodeGuru Reviewer, see the Amazon CodeGuru Reviewer User Guide.

To improve the security of your CodeGuru Reviewer API calls, you can establish a private connection between your VPC and CodeGuru Reviewer by creating an interface VPC endpoint. For more information, see CodeGuru Reviewer and interface VPC endpoints (Amazon Web Services PrivateLink) in the Amazon CodeGuru Reviewer User Guide.

Usage

codegurureviewer(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codegurureviewer(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codegurureviewer()
svc$associate_repository(
  Foo = 123
)

## End(Not run)

Description

Amazon CodeGuru Security is in preview release and is subject to change.

This section provides documentation for the Amazon CodeGuru Security API operations. CodeGuru Security is a service that uses program analysis and machine learning to detect security policy violations and vulnerabilities, and recommends ways to address these security risks.

By proactively detecting and providing recommendations for addressing security risks, CodeGuru Security improves the overall security of your application code. For more information about CodeGuru Security, see the Amazon CodeGuru Security User Guide.

Usage

codegurusecurity(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codegurusecurity(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codegurusecurity()
svc$batch_get_findings(
  Foo = 123
)

## End(Not run)

Description

CodePipeline

Overview

This is the CodePipeline API Reference. This guide provides descriptions of the actions and data types for CodePipeline. Some functionality for your pipeline can only be configured through the API. For more information, see the CodePipeline User Guide.

You can use the CodePipeline API to work with pipelines, stages, actions, and transitions.

Pipelines are models of automated release processes. Each pipeline is uniquely named, and consists of stages, actions, and transitions.

You can work with pipelines by calling:

• create_pipeline, which creates a uniquely named pipeline.

• delete_pipeline, which deletes the specified pipeline.

• get_pipeline, which returns information about the pipeline structure and pipeline metadata, including the pipeline Amazon Resource Name (ARN).

• get_pipeline_execution, which returns information about a specific execution of a pipeline.

• get_pipeline_state, which returns information about the current state of the stages and actions of a pipeline.

• list_action_executions, which returns action-level details for past executions. The details include full stage and action-level details, including individual action duration, status, any errors that occurred during the execution, and input and output artifact location details.

• list_pipelines, which gets a summary of all of the pipelines associated with your account.

• list_pipeline_executions, which gets a summary of the most recent executions for a pipeline.

• start_pipeline_execution, which runs the most recent revision of an artifact through the pipeline.

• stop_pipeline_execution, which stops the specified pipeline execution from continuing through the pipeline.

• update_pipeline, which updates a pipeline with edits or changes to the structure of the pipeline.

Pipelines include stages. Each stage contains one or more actions that must complete before the next stage begins. A stage results in success or failure. If a stage fails, the pipeline stops at that stage and remains stopped until either a new version of an artifact appears in the source location, or a user takes action to rerun the most recent artifact through the pipeline. You can call get_pipeline_state, which displays the status of a pipeline, including the status of stages in the pipeline, or get_pipeline, which returns the entire structure of the pipeline, including the stages of that pipeline. For more information about the structure of stages and actions, see CodePipeline Pipeline Structure Reference.

Pipeline stages include actions that are categorized into categories such as source or build actions performed in a stage of a pipeline. For example, you can use a source action to import artifacts into a pipeline from a source such as Amazon S3. Like stages, you do not work with actions directly in most cases, but you do define and interact with actions when working with pipeline operations such as create_pipeline and get_pipeline_state. Valid action categories are:

• Source

• Build

• Test

• Deploy

• Approval

• Invoke

Pipelines also include transitions, which allow the transition of artifacts from one stage to the next in a pipeline after the actions in one stage complete.

You can work with transitions by calling:

• disable_stage_transition, which prevents artifacts from transitioning to the next stage in a pipeline.

• enable_stage_transition, which enables transition of artifacts between stages in a pipeline.

Using the API to integrate with CodePipeline

For third-party integrators or developers who want to create their own integrations with CodePipeline, the expected sequence varies from the standard API user. To integrate with CodePipeline, developers need to work with the following items:

Jobs, which are instances of an action. For example, a job for a source action might import a revision of an artifact from a source.

You can work with jobs by calling:

• acknowledge_job, which confirms whether a job worker has received the specified job.

• get_job_details, which returns the details of a job.

• poll_for_jobs, which determines whether there are any jobs to act on.

• put_job_failure_result, which provides details of a job failure.

• put_job_success_result, which provides details of a job success.

Third party jobs, which are instances of an action created by a partner action and integrated into CodePipeline. Partner actions are created by members of the Amazon Web Services Partner Network.

You can work with third party jobs by calling:

• acknowledge_third_party_job, which confirms whether a job worker has received the specified job.

• get_third_party_job_details, which requests the details of a job for a partner action.

• poll_for_third_party_jobs, which determines whether there are any jobs to act on.

• put_third_party_job_failure_result, which provides details of a job failure.

• put_third_party_job_success_result, which provides details of a job success.

Usage

codepipeline(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codepipeline(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codepipeline()
svc$acknowledge_job(
  Foo = 123
)

## End(Not run)

Description

AWS CodeStar Connections

This Amazon Web Services CodeStar Connections API Reference provides descriptions and usage examples of the operations and data types for the Amazon Web Services CodeStar Connections API. You can use the connections API to work with connections and installations.

Connections are configurations that you use to connect Amazon Web Services resources to external code repositories. Each connection is a resource that can be given to services such as CodePipeline to connect to a third-party repository such as Bitbucket. For example, you can add the connection in CodePipeline so that it triggers your pipeline when a code change is made to your third-party code repository. Each connection is named and associated with a unique ARN that is used to reference the connection.

When you create a connection, the console initiates a third-party connection handshake. Installations are the apps that are used to conduct this handshake. For example, the installation for the Bitbucket provider type is the Bitbucket app. When you create a connection, you can choose an existing installation or create one.

When you want to create a connection to an installed provider type such as GitHub Enterprise Server, you create a host for your connections.

You can work with connections by calling:

• create_connection, which creates a uniquely named connection that can be referenced by services such as CodePipeline.

• delete_connection, which deletes the specified connection.

• get_connection, which returns information about the connection, including the connection status.

• list_connections, which lists the connections associated with your account.

You can work with hosts by calling:

• create_host, which creates a host that represents the infrastructure where your provider is installed.

• delete_host, which deletes the specified host.

• get_host, which returns information about the host, including the setup status.

• list_hosts, which lists the hosts associated with your account.

You can work with tags in Amazon Web Services CodeStar Connections by calling the following:

• list_tags_for_resource, which gets information about Amazon Web Services tags for a specified Amazon Resource Name (ARN) in Amazon Web Services CodeStar Connections.

• tag_resource, which adds or updates tags for a resource in Amazon Web Services CodeStar Connections.

• untag_resource, which removes tags for a resource in Amazon Web Services CodeStar Connections.

For information about how to use Amazon Web Services CodeStar Connections, see the Developer Tools User Guide.

Usage

codestarconnections(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codestarconnections(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codestarconnections()
svc$create_connection(
  Foo = 123
)

## End(Not run)

Description

This AWS CodeStar Notifications API Reference provides descriptions and usage examples of the operations and data types for the AWS CodeStar Notifications API. You can use the AWS CodeStar Notifications API to work with the following objects:

Notification rules, by calling the following:

• create_notification_rule, which creates a notification rule for a resource in your account.

• delete_notification_rule, which deletes a notification rule.

• describe_notification_rule, which provides information about a notification rule.

• list_notification_rules, which lists the notification rules associated with your account.

• update_notification_rule, which changes the name, events, or targets associated with a notification rule.

• subscribe, which subscribes a target to a notification rule.

• unsubscribe, which removes a target from a notification rule.

Targets, by calling the following:

• delete_target, which removes a notification rule target from a notification rule.

• list_targets, which lists the targets associated with a notification rule.

Events, by calling the following:

• list_event_types, which lists the event types you can include in a notification rule.

Tags, by calling the following:

• list_tags_for_resource, which lists the tags already associated with a notification rule in your account.

• tag_resource, which associates a tag you provide with a notification rule in your account.

• untag_resource, which removes a tag from a notification rule in your account.

For information about how to use AWS CodeStar Notifications, see the Amazon Web Services Developer Tools Console User Guide.

Usage

codestarnotifications(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- codestarnotifications(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- codestarnotifications()
svc$create_notification_rule(
  Foo = 123
)

## End(Not run)

Description

Amazon DevOps Guru is a fully managed service that helps you identify anomalous behavior in business critical operational applications. You specify the Amazon Web Services resources that you want DevOps Guru to cover, then the Amazon CloudWatch metrics and Amazon Web Services CloudTrail events related to those resources are analyzed. When anomalous behavior is detected, DevOps Guru creates an insight that includes recommendations, related events, and related metrics that can help you improve your operational applications. For more information, see What is Amazon DevOps Guru.

You can specify 1 or 2 Amazon Simple Notification Service topics so you are notified every time a new insight is created. You can also enable DevOps Guru to generate an OpsItem in Amazon Web Services Systems Manager for each insight to help you manage and track your work addressing insights.

To learn about the DevOps Guru workflow, see How DevOps Guru works. To learn about DevOps Guru concepts, see Concepts in DevOps Guru.

Usage

devopsguru(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- devopsguru(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- devopsguru()
svc$add_notification_channel(
  Foo = 123
)

## End(Not run)

Description

AWS Elastic Disaster Recovery Service.

Usage

drs(config = list(), credentials = list(), endpoint = NULL, region = NULL)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- drs(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- drs()
svc$associate_source_network_stack(
  Foo = 123
)

## End(Not run)

Description

Amazon Web Services Fault Injection Service is a managed service that enables you to perform fault injection experiments on your Amazon Web Services workloads. For more information, see the Fault Injection Service User Guide.

Usage

fis(config = list(), credentials = list(), endpoint = NULL, region = NULL)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- fis(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- fis()
svc$create_experiment_template(
  Foo = 123
)

## End(Not run)

Description

Well-Architected Tool

This is the Well-Architected Tool API Reference. The WA Tool API provides programmatic access to the Well-Architected Tool in the Amazon Web Services Management Console. For information about the Well-Architected Tool, see the Well-Architected Tool User Guide.

Usage

wellarchitected(
  config = list(),
  credentials = list(),
  endpoint = NULL,
  region = NULL
)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- wellarchitected(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- wellarchitected()
svc$associate_lenses(
  Foo = 123
)

## End(Not run)

Description

Amazon Web Services X-Ray provides APIs for managing debug traces and retrieving service maps and other data created by processing those traces.

Usage

xray(config = list(), credentials = list(), endpoint = NULL, region = NULL)

Arguments

Value

A client for the service. You can call the service's operations using syntax like svc$operation(...), where svc is the name you've assigned to the client. The available operations are listed in the Operations section.

Service syntax

svc <- xray(
  config = list(
    credentials = list(
      creds = list(
        access_key_id = "string",
        secret_access_key = "string",
        session_token = "string"
      ),
      profile = "string",
      anonymous = "logical"
    ),
    endpoint = "string",
    region = "string",
    close_connection = "logical",
    timeout = "numeric",
    s3_force_path_style = "logical",
    sts_regional_endpoint = "string"
  ),
  credentials = list(
    creds = list(
      access_key_id = "string",
      secret_access_key = "string",
      session_token = "string"
    ),
    profile = "string",
    anonymous = "logical"
  ),
  endpoint = "string",
  region = "string"
)

Operations

Examples

## Not run: 
svc <- xray()
svc$batch_get_traces(
  Foo = 123
)

## End(Not run)