Ubuntu 26.04 + Docker build a Go Gin development environment (full record)

Seamlessly migrate from Windows WSL2 to Ubuntu bare metal, build Go development environments based on existing MySQL/Redis containers, and access custom networks.

📌 Preface

I have been learning in Windows 10 + WSL2 before go-gin-learning Project, now to brand new Ubuntu 26.04 system. I hope to continue to use Docker to isolate the sending environment, and at the same time reuse the deployed MySQL 8.0 and Redis 7.2 containers (located on a custom network services_dev-network in).

This article records all the steps of configuring from scratch, including:

• System tool check and installation
• Docker environment verification
• Project code clone
• Write a Dockerfile preinstall git
• Write docker-compose.yml to access existing networks
• Run GIN applications inside the container and test connectivity
• 常见问题与避坑建议

🧰 1. Preparation: Check the existing tools of the system

Develop the habit of ‘check first, then install’ in Ubuntu, which can avoid repeated operations.

1.1 Check git

git --version

Output example(installed):

git version 2.53.0

If not installed, execute:

sudo apt install git -y

1.2 Check Docker

docker --version
docker compose version

Output example:

Docker version 29.5.2, build 79eb04c
Docker Compose version v5.1.4

If not installed, please refer to Docker official documentation install.

✅ Recommend: add the current user docker group, avoid each input sudo:

sudo usermod -aG docker $USER

ThenLog out and log in again.

🌐 2. Confirm the existing database network environment

Already in ~/docker/services MySQL 8.0 and Redis 7.2 were run via docker-compose.yml and a custom network was created services_dev-network.

2.1 View the network

docker network ls | grep dev-network

Export:

71f462c6ef91   services_dev-network   bridge    local

2.2 View the database container status

docker ps --filter "name=mysql80" --filter "name=redis72"

Export:

CONTAINER ID   IMAGE       ...   NAMES
9ec38ca384b6   redis:7.2   ...   redis72
4e93fd2e2c3f   mysql:8.0   ...   mysql80

💡 key information:

• MySQL container name:mysql80, internal port 3306, host map port 3307
• Redis container name:redis72, internal port 6379
• Network name:services_dev-network((attention prefix, by ~/docker/services directory name derived)

📁 3. Create the code directory and clone the project

Select a directory with clear semantics to store the project code, use here ~/code(All lowercase, in accordance with Linux conventions).

mkdir -p ~/code
cd ~/code
git clone https://github.com/shuijingwan/go-gin-learning.git
cd go-gin-learning

Check the project structure:

ls -la

🐳 4. Write a Dockerfile (pre-installed git)

In order not to manually install each time the container is entered git, we create a custom image.

Create dockerfile:

FROM golang:1.26-alpine

# 安装 git（go mod 下载某些依赖时需要）
RUN apk add --no-cache git

# 设置工作目录，与后面的 docker-compose 保持一致
WORKDIR /code

# 保持容器运行（开发模式）
CMD ["tail", "-f", "/dev/null"]

📌 Explanation:

• Use Alpine version image, small size
• apk add --no-cache Do not keep the cache, reduce the image size
• workdir /code You can omit the docker-compose in the future working_dir, but in order to be clear, it is no problem to keep both sides

⚙️ 5. Write docker-compose.yml (connect to the existing network)

Key points:

• Use build: . instead of image: ...
• Join an external network services_dev-network
• The environment variables required to pass the database connection
• delete obsolete version numeric field

Final docker-compose.yml Content:

services:
  go:
    build: .
    container_name: go-gin-learning
    working_dir: /code
    volumes:
      - ./:/code
    ports:
      - "8080:8080"
    tty: true
    stdin_open: true
    environment:
      - GOPROXY=https://goproxy.io,direct
      - GOSUMDB=sum.golang.google.cn
      - CGO_ENABLED=0
      # 数据库连接配置（使用现有网络中的服务名）
      - DB_HOST=mysql80
      - DB_PORT=3306
      - DB_USER=root
      - DB_PASSWORD=mystrongpwd80
      - DB_NAME=go_gin
      - REDIS_HOST=redis72
      - REDIS_PORT=6379
      - REDIS_PASSWORD=myredispass
    networks:
      - services_dev-network

networks:
  services_dev-network:
    external: true

⚠️ Note:

• db_password And redis_password to with ~/docker/services/docker-compose.yml password inCompletely consistent.
• Use of communication between containersinternal port 3306 and 6379, not the host mapped 3307.

🚀 Build and start development containers

# 停止并删除旧容器（如果有）
docker compose down

# 构建镜像（--no-cache 确保重新安装 git）
docker compose build --no-cache

# 启动容器（后台运行）
docker compose up -d

Check the running status:

docker ps --filter "name=go-gin-learning"

🧪 7. Enter the container and verify the connection

7.1 Enter the container

docker exec -it go-gin-learning sh

The prompt becomes /code #.

7.2 Verify that Git is installed

git --version

should output similar Git version 2.52.0.

7.3 Test network connectivity

# 安装测试工具（仅调试用，正式镜像可不加）
apk add iputils mysql-client redis

# ping 数据库容器
ping -c 2 mysql80
ping -c 2 redis72

7.4 Test MySQL connections (SSL disabled)

MySQL 8.0 defaults to SSL, but is used inside the container --ssl=0 You can bypass certificate verification:

mariadb -h mysql80 -P 3306 -u root -pmystrongpwd80 -e "SHOW DATABASES;" --ssl=0

expected output: as shown in Figure 1

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+

💡 If using mysql command, please use --ssl-mode=disabled.

7.5 Test Redis Connections

redis-cli -h redis72 -a myredispass PING

expected output: as shown in Figure 2

PONG

🏃 8. Run the GIN application

Execute inside the container:

go run main.go

Seeing the following log indicates success: as shown in Figure 3

go: downloading github.com/go-playground/locales v0.14.1
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:	export GIN_MODE=release
 - using code:	gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /albums                   --> main.getAlbums (3 handlers)
[GIN-debug] GET    /albums/:id               --> main.getAlbumByID (3 handlers)
[GIN-debug] POST   /albums                   --> main.postAlbums (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
Please check https://github.com/gin-gonic/gin/blob/master/docs/doc.md#dont-trust-all-proxies for details.
[GIN-debug] Listening and serving HTTP on 0.0.0.0:8080
[GIN] 2026/06/03 - 11:19:14 | 404 |  1.219µs |      172.18.0.1 | GET      "/"
[GIN] 2026/06/03 - 11:19:14 | 404 |    778ns |      172.18.0.1 | GET      "/favicon.ico"
[GIN] 2026/06/03 - 11:19:45 | 200 | 147.412µs |      172.18.0.1 | GET      "/albums"

Test API on the host

Open another terminal and execute:

curl http://localhost:8080/albums

or directly in the browser http://localhost:8080/albums.

📸 The browser displays JSON data, as shown in Figure 4

🧹 Nine, common management commands

⚠️ 10. Guide to Pits

10.1 Inside the container git loss leads to go run Failure

Phenomenon:

unable to resolve git version: exec: "git": executable file not found in $PATH

Solve: Install using a custom Dockerfile git, see Chapter 4.

10.2 MySQL connection reports TLS/SSL error

Phenomenon:

ERROR 2026 (HY000): TLS/SSL error: Certificate verification failure

Solve: add in the connection command --ssl=0(mariadb) or --ssl-mode=disabled(mysql).

10.3 Containers cannot access mysql/redis

Reason: The correct network is not added, or the network name is wrong.

Solve:

• Confirm docker network ls Middle services_dev-network
• Check in docker-compose.yml networks Is the name yesCompletely consistent(including underscore)
• in the container ping mysql80 Test

10.4 Host cannot access port 8080

Reason: GIN is listening for 127.0.0.1:8080 instead of 0.0.0.0:8080, causing the port mapping to fail.

Solve: set in the code router.run(':8080') Or router.run('0.0.0.0:8080').

📝 Eleven, summary

Through this practice, I have achieved:

1. ✅ Build a complete Go development environment on Ubuntu 26.04
2. ✅ Take advantage of existing MySQL/Redis containers (independent deployment) and custom networks
3. ✅ Build belt git Go 1.26 Alpine development image
4. ✅ Writing docker-compose.yml mount code and access external network
5. ✅ Successfully run the GIN application inside the container and verify the database connectivity

This ‘Database and code separation container” model is very suitable for multi-project shared infrastructure, saving resources and maintaining environmental consistency.

Next, you can:

• In main.go Write the business logic to connect to MySQL/Redis
• Use any code editor (such as VS Code, Sublime, etc.) to directly edit the project file, and synchronize in real time in the container after saving
• Will docker-compose.yml Join version control to share environment configuration with teammates

🔗 References

• GIN official documentation
• Docker Compose Network Documentation
• Alpine Linux Package Management