mips64le/golang
Go (golang) is a general purpose, higher-level, imperative programming language.
100K+
Note: this is the "per-architecture" repository for the mips64le
builds of the golang
official image -- for more information, see "Architectures other than amd64?" in the official images documentation and "An image's source changed in Git, now what?" in the official images FAQ.
Maintained by:
the Docker Community
Where to get help:
the Docker Community Slack, Server Fault, Unix & Linux, or Stack Overflow
Dockerfile
links(See "What's the difference between 'Shared' and 'Simple' tags?" in the FAQ.)
1.24.0
, 1.24
, 1
, latest
:
1.23.6
, 1.23
:
Where to file issues:
https://github.com/docker-library/golang/issues
Supported architectures: (more info)amd64
, arm32v6
, arm32v7
, arm64v8
, i386
, mips64le
, ppc64le
, riscv64
, s390x
, windows-amd64
Published image artifact details:
repo-info repo's repos/golang/
directory (history)
(image metadata, transfer size, etc)
Image updates:
official-images repo's library/golang
label
official-images repo's library/golang
file (history)
Source of this description:
docs repo's golang/
directory (history)
Go (a.k.a., Golang) is a programming language first developed at Google. It is a statically-typed language with syntax loosely derived from C, but with additional features such as garbage collection, type safety, some dynamic-typing capabilities, additional built-in types (e.g., variable-length arrays and key-value maps), and a large standard library.
Note:/go
is world-writable to allow flexibility in the user which runs the container (for example, in a container started with --user 1000:1000
, running go get github.com/example/...
into the default $GOPATH
will succeed). While the 777
directory would be insecure on a regular host setup, there are not typically other processes or users inside the container, so this is equivalent to 700
for Docker usage, but allowing for --user
flexibility.
The most straightforward way to use this image is to use a Go container as both the build and runtime environment. In your Dockerfile
, writing something along the lines of the following will compile and run your project (assuming it uses go.mod
for dependency management):
FROM mips64le/golang:1.23
WORKDIR /usr/src/app
# pre-copy/cache go.mod for pre-downloading dependencies and only redownloading them in subsequent builds if they change
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN go build -v -o /usr/local/bin/app ./...
CMD ["app"]
You can then build and run the Docker image:
$ docker build -t my-golang-app .
$ docker run -it --rm --name my-running-app my-golang-app
There may be occasions where it is not appropriate to run your app inside a container. To compile, but not run your app inside the Docker instance, you can write something like:
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp mips64le/golang:1.23 go build -v
This will add your current directory as a volume to the container, set the working directory to the volume, and run the command go build
which will tell go to compile the project in the working directory and output the executable to myapp
. Alternatively, if you have a Makefile
, you can run the make
command inside your container.
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp mips64le/golang:1.23 make
If you need to compile your application for a platform other than linux/amd64
(such as windows/386
):
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp -e GOOS=windows -e GOARCH=386 mips64le/golang:1.23 go build -v
Alternatively, you can build for multiple platforms at once:
$ docker run --rm -it -v "$PWD":/usr/src/myapp -w /usr/src/myapp mips64le/golang:1.23 bash
$ for GOOS in darwin linux; do
> for GOARCH in 386 amd64; do
> export GOOS GOARCH
> go build -v -o myapp-$GOOS-$GOARCH
> done
> done
If downloading your dependencies results in an error like "checksum mismatch", you should check whether they are using Git LFS (and thus need it installed for downloading them and calculating correct go.sum
values).
View license information for the software contained in this image.
As with all Docker images, these likely also contain other software which may be under other licenses (such as Bash, etc from the base distribution, along with any direct or indirect dependencies of the primary software being contained).
Some additional license information which was able to be auto-detected might be found in the repo-info
repository's golang/
directory.
As for any pre-built image usage, it is the image user's responsibility to ensure that any use of this image complies with any relevant licenses for all software contained within.
docker pull mips64le/golang