Use Go with JFrog CLI

Run Go commands with Artifactory integration, including configuration, builds, and publishing.

This topic covers the following tasks:

• Configure Go for Artifactory (jf go-config)
• Run Go commands (jf go)
• Publish Go modules (jf go-publish)

When to Use

Use jf go if your Go project uses Go modules (go.mod) and you want dependencies resolved from Artifactory. The CLI wraps go build, go get, and other Go commands while setting GOPROXY to point at your Artifactory Go repository.

Prerequisites

• Go must be installed (Go 1.16+ recommended for module support). Verify with go version.
• A Go module must exist in the current directory (go.mod). Initialize one with:
  Bash

  go mod init <module-path>

  For example: go mod init github.com/my-org/my-app
• JFrog CLI server configured. See jf config add — note the server ID, as it is required by jf go-config.
• Authentication: A valid Artifactory access token is required. If your token is a reference token (non-JWT), the CLI will emit a [Warn] about it — Go builds still succeed, but fetching modules from Artifactory with jf go get may fail with 401. Re-run jf config add with a username if you encounter auth errors.
• Run jf go-config in the project directory before the first build.

Configuration: jf go-config

Generate Go build configuration for dependency resolution and deployment. Run this once per project before your first build.

To configure Go for Artifactory:

1. From your Go module directory, run jf go-config with resolve and deploy server IDs and repository keys (see Non-Interactive Configuration with Flags).
2. Confirm .jfrog/projects/go.yaml exists and matches your settings (see How to Verify).

Synopsis

jf go-config [options]

Aliases: goc

Configuration Options

Configuration Examples

View Help

jf go-config --help

Non-Interactive Configuration with Flags

jf go-config --server-id-resolve=<server-id> --repo-resolve=<repo-name> --server-id-deploy=<server-id> --repo-deploy=<repo-name>

Where:

• <server-id>: The server ID configured using jf config add
• <repo-name>: The name of the repository in Artifactory

For example:

jf go-config --server-id-resolve=my-server --repo-resolve=go-virtual --server-id-deploy=my-server --repo-deploy=go-local

Why Run Config First?

You must run jf go-config before jf go or jf go-publish. The config tells the CLI which Artifactory Go repositories to use, setting GOPROXY automatically during builds. Without it, jf go does not know where to fetch or publish modules.

👍

Shortcut

: In CI/CD, pass all flags non-interactively so the config step is fully automated and reproducible.

Configuration Notes

• Run once per project: Configuration persists in .jfrog/projects/go.yaml.
• Resolution and deployment: Use --repo-resolve for fetching modules and --repo-deploy for publishing.
• GOPROXY override: The CLI temporarily sets GOPROXY during execution, overriding any system setting.

Expected Output

$ jf go-config --server-id-resolve=my-server --repo-resolve=go-virtual --server-id-deploy=my-server --repo-deploy=go-local
[Info] go build config successfully created.

How to Verify

After running, confirm the configuration exists:

cat .jfrog/projects/go.yaml

The file should contain:

version: 1
type: go
resolver:
    repo: <repo-resolve>
    serverId: <server-id-resolve>
deployer:
    repo: <repo-deploy>
    serverId: <server-id-deploy>

Where the repo and serverId values match what you passed to jf go-config.

Build: jf go

Run Go commands with Artifactory integration and optional build-info collection.

To run Go commands with Artifactory integration:

1. Run jf go-config in the module directory if you have not already (see Configuration).
2. From the module root, run jf go with the Go subcommand and arguments, adding --build-name and --build-number when you want build-info (see Build Examples).

Synopsis

jf go <go-arguments> [options]

Aliases: none

Arguments

Build Options

Build Examples

📘

Note

Run these commands from the root of your Go module directory (where your go.mod file lives), and only after running jf go-config in that directory.

View Help

jf go --help

Run a Go Build

jf go build ./...

On success, the command exits without error. Check the exit code to confirm (echo $? should return 0).

Run Go with Build-Info Collection

jf go build ./... --build-name=<build-name> --build-number=<build-number>

Where:

• <build-name> is a name for the build (for example, my-go-app)
• <build-number> is a number or identifier for the build run (for example, 1)

For example:

jf go build ./... --build-name=my-go-app --build-number=1

Run Go Get with No VCS Fallback

To fetch a module exclusively from Artifactory (no fallback to public VCS):

jf go get <package> --no-fallback

Where:

• <package> is the Go module path (for example, github.com/example/lib)

For example:

jf go get github.com/example/lib --no-fallback

👍

Tip

Without --no-fallback, the CLI will fall back to the public VCS (for example, GitHub) if the module is not found in Artifactory. This is the default behavior.

Publish Build Info

After building with --build-name and --build-number, publish the collected build info to Artifactory:

jf rt build-publish <build-name> <build-number>

For example:

jf rt build-publish my-go-app 1

👍

Tip

jf rt bp is a shorthand alias for jf rt build-publish.

Publish: jf go-publish

Publish a Go package and its dependencies to Artifactory.

To publish a Go package to Artifactory:

1. Ensure jf go-config is in place and you are in the module directory (see Configuration).
2. Run jf go-publish with the module version and any required flags (see Publish Examples).

Synopsis

jf go-publish <project-version> [options]

Aliases: gp

Arguments

Publish Options

Publish Examples

View Help

jf go-publish --help

Publish a Package Version

jf go-publish v1.0.0

Publish with Build-Info and Detailed Summary

jf go-publish v1.0.0 --build-name=my-app --build-number=1 --detailed-summary

Publish with Exclusions

jf go-publish v1.0.0 --exclusions="test/*;*.md"

Important Notes

• VCS fallback: By default, --no-fallback is false, meaning the CLI will fall back to the public VCS (for example, GitHub) if a module is missing in Artifactory. To enforce Artifactory-only resolution and disable VCS fallback, pass --no-fallback or --no-fallback=true.
• GOPROXY: The CLI sets GOPROXY to point at your Artifactory Go repository. This overrides any existing GOPROXY setting for the duration of the command.
• Build-info: Use --build-name and --build-number to collect dependency information, then publish with jf rt build-publish.
• Version format: The version must follow Go module versioning (for example, v1.0.0, v2.1.3). The v prefix is required.
• Exclusions: Use --exclusions to exclude test files, documentation, or other files you don't want in the published module.

Platform Notes

• Windows: Go module archive creation may behave differently with path separators. Use forward slashes in exclusion patterns.
• macOS / Linux: GOPROXY environment variable is temporarily overridden during jf go execution. Check with go env GOPROXY after the command completes to verify it was restored.

CI/CD Example (GitHub Actions)

# .github/workflows/build.yml
steps:
  - uses: actions/checkout@v4
  - name: Setup JFrog CLI
    uses: jfrog/setup-jfrog-cli@v4
    env:
      JF_URL: ${{ vars.JF_URL }}
      JF_ACCESS_TOKEN: ${{ secrets.JF_ACCESS_TOKEN }}
  - name: Configure Go
    run: jf go-config --server-id-resolve=setup-jfrog-cli-server --repo-resolve=go-virtual --server-id-deploy=setup-jfrog-cli-server --repo-deploy=go-local
  - name: Build
    run: jf go build --build-name=my-go-app --build-number=${{ github.run_number }} --no-fallback
  - name: Publish module
    run: jf go-publish v1.0.0 --build-name=my-go-app --build-number=${{ github.run_number }}
  - name: Publish build info
    run: jf rt build-publish my-go-app ${{ github.run_number }}

Troubleshooting

Enable debug logging: export JFROG_CLI_LOG_LEVEL=DEBUG

Related Topics

• Build Tools Overview — Capabilities matrix and tool reference
• Native Mode — Supported packages with Native Mode