eb7ba2a294
* outlines gitlab client integration
* makes client parameter more explicit
* adds gitlab url to config
* changes releaseID to string to adapt to gitlab
* updates to latest gitlab client lib 0.18
* fixes copy paster in gitlab upload func
* fixes gitlab typo in config
* adds gitlab token to env and context
* release now uses the client factory method
* skips brew pipe if it is not a github release
* add github tokentype to publish tests
* skips scoop pipe if it is not a github release
* corrects brew skip msg
* adds gitlab token to main test
* adds gitlab to release docs
* validates config and errors accordingly
* adapt release pipe name to include gitlab
* fixes gitlab client after testing
* moves not-configured brew and scoop pipe checks as first check
* adds more debug to gitlab client
* adapts changelog generation for gitlab markdown
* adds debug log for gitlab changelog
* env needs to run before changelog pipe
* moves gitlab default download url to default pipe
* moves multiple releases check to from config to release pipe
* release differs now for github and gitlab
* adds debug gitlab release update msgs
* moves env pipe as second after before because it determines the token type other pipes depend on
* adaptes error check on gitlab release creation
* Revert "adaptes error check on gitlab release creation"
This reverts commit 032024571c.
* simplifies gitlab client logic. removes comments
* skips tls verification for gitlab client if specified in config
* updates the docs
* adds clarification that brew and scoop are not supported if it is a gitlab release
* fixes copy paster in release.md
* adds missing blob pipe in defaults and publish due to missing in merge
* updates comment in gitlab client
3.4 KiB
| title | weight | menu |
|---|---|---|
| Quick Start | 10 | true |
In this example we will build, archive and release a sample Go project.
Create a GitHub repository and add a single main package:
// main.go
package main
func main() {
println("Ba dum, tss!")
}
Run goreleaser init to create an example .goreleaser.yaml file:
$ goreleaser init
• Generating .goreleaser.yml file
• config created; please edit accordingly to your needs file=.goreleaser.yml
You can customize the generated .goreleaser.yml or leave
it as-is, it's up to you.
You can test the configuration at any time by running GoReleaser with a few extra parameters to not require a version tag, skip publishing to GitHub, and remove any already-built files:
$ goreleaser --snapshot --skip-publish --rm-dist
If you are not using vgo or Go modules, then you will need to comment out the before hooks in the generated config file or update them to match your setup accordingly.
GoReleaser will build the binaries for your app for Windows, Linux and macOS,
both amd64 and i386 architectures. You can customize that by changing the
builds section. Check the documentation for more information.
After building the binaries, GoReleaser will create an archive for each OS/Arch
pair into a separate file. You can customize several things by changing
the archive section, including releasing only the binaries and not creating
archives at all. Check the documentation for more information.
You'll need to export either a GITHUB_TOKEN or GITLAB_TOKEN environment variable, which should
contain a valid GitHub token with the repo scope or GitLab token with api scope.
It will be used to deploy releases to your GitHub/GitLab repository.
You can create a token here for GitHub or here for GitLab.
$ export GITHUB_TOKEN=`YOUR_GH_TOKEN`
# or
$ export GITLAB_TOKEN=`YOUR_GL_TOKEN`
GoReleaser will use the latest Git tag of your repository. Create a tag and push it to GitHub:
$ git tag -a v0.1.0 -m "First release"
$ git push origin v0.1.0
Attention: Check if your tag adheres to semantic versioning.
If you don't want to create a tag yet, you can also create a release
based on the latest commit by using the --snapshot flag. (Note: ony GitHub supports snapshots)
Now you can run GoReleaser at the root of your repository:
$ goreleaser
That's all! Check your GitHub project's release page. The release should look like this:
Or check your GitLab project's release page.
The release should also look like this:
Dry run
If you want to test everything before doing a release "for real", you can
use the --skip-publish flag, which will only build and package things:
$ goreleaser release --skip-publish
You can check the other options by running:
$ goreleaser --help
and
$ goreleaser release --help