go mod init github path
go get ./.. go test ./..
go build
Main applications for this project.
The directory name for each application should match the name of the executable you want to have (e.g., /cmd/myapp
).
Don't put a lot of code in the application directory. If you think the code can be imported and used in other projects, then it should live in the /pkg
directory. If the code is not reusable or if you don't want others to reuse it, put that code in the /internal
directory. You'll be surprised what others will do, so be explicit about your intentions!
It's common to have a small main
function that imports and invokes the code from the /internal
and /pkg
directories and nothing else.
Private application and library code. This is the code you don't want others importing in their applications or libraries.
Put your actual application code in the /internal/app
directory (e.g., /internal/app/myapp
) and the code shared by those apps in the /internal/pkg
directory (e.g., /internal/pkg/myprivlib
).
Library code that's ok to use by external applications (e.g., /pkg/mypubliclib
). Other projects will import these libraries expecting them to work, so think twice before you put something here :-)
It's also a way to group Go code in one place when your root directory contains lots of non-Go components and directories making it easier to run various Go tools (as mentioned in the Best Practices for Industrial Programming
from GopherCon EU 2018).
Application dependencies (managed manually or by your favorite dependency management tool like dep
).
Don't commit your application dependencies if you are building a library.
OpenAPI/Swagger specs, JSON schema files, protocol definition files.
Web application specific components: static web assets, server side templates and SPAs.
Configuration file templates or default configs.
Put your confd
or consul-template
template files here.
System init (systemd, upstart, sysv) and process manager/supervisor (runit, supervisord) configs.
Scripts to perform various build, install, analysis, etc operations.
These scripts keep the root level Makefile small and simple (e.g., https://github.com/hashicorp/terraform/blob/master/Makefile
).
Packaging and Continuous Integration.
Put your cloud (AMI), container (Docker), OS (deb, rpm, pkg) package configurations and scripts in the /build/package
directory.
Put your CI (travis, circle, drone) configurations and scripts in the /build/ci
directory. Note that some of the CI tools (e.g., Travis CI) are very picky about the location of their config files. Try putting the config files in the /build/ci
directory linking them to the location where the CI tools expect them (when possible).
IaaS, PaaS, system and container orchestration deployment configurations and templates (docker-compose, kubernetes/helm, mesos, terraform, bosh).
Additional external test apps and test data. Feel free to structure the /test
directory anyway you want. For bigger projects it makes sense to have a data subdirectory. For example, you can have /test/data
or /test/testdata
if you need Go to ignore what's in that directory. Note that Go will also ignore directories or files that begin with "." or "_", so you have more flexibility in terms of how you name your test data directory.
Design and user documents (in addition to your godoc generated documentation).
Supporting tools for this project. Note that these tools can import code from the /pkg
and /internal
directories.
Examples for your applications and/or public libraries.
External helper tools, forked code and other 3rd party utilities (e.g., Swagger UI).
Git hooks.
Other assets to go along with your repository (images, logos, etc).
This is the place to put your project's website data if you are not using Github pages.