How can I run docker-compose from Go so that the updated .env file is recognized?

Below is an explanation that may help resolve your issue.

What’s Happening

When you call exec.Command from your Go service, the new process inherits its parent's environment. Docker Compose first loads environment variables from its process’s environment and then applies values from the .env file only for variables that are missing. This means that if your Go service already has those variables set (even to outdated values), Docker Compose will ignore updates you’ve made in the .env file.

How to Address It

You have two common options:

1. Clean Up or Override the Environment

   Before you run the docker-compose command, you can create a clean environment for the child process so that Docker Compose is forced to load variables from the .env file. For instance, read the .env file and then set the command’s environment explicitly. Here’s an example:

   GOCopied
   package main
   
   import (
       "io/ioutil"
       "log"
       "os"
       "os/exec"
       "strings"
   )
   
   // loadEnv reads a .env file and returns a slice of "KEY=value"
   func loadEnv(filename string) ([]string, error) {
       content, err := ioutil.ReadFile(filename)
       if err != nil {
           return nil, err
       }
       var envs []string
       for _, line := range strings.Split(string(content), "\n") {
           line = strings.TrimSpace(line)
           if len(line) == 0 || strings.HasPrefix(line, "#") {
               continue
           }
           envs = append(envs, line)
       }
       return envs, nil
   }
   
   func runCommand() error {
       envVars, err := loadEnv(".env")
       if err != nil {
           return err
       }
       // Optionally combine with some system environment vars if needed.
       // For a clean environment, simply use envVars.
       cmd := exec.Command("docker-compose", "up", "--build", "-d")
       // Set the working directory to where your docker-compose.yml and .env file reside.
       cmd.Dir = "/path/to/your/directory"
       cmd.Env = envVars
   
       output, err := cmd.CombinedOutput()
       if err != nil {
           return err
       }
       log.Printf("run docker-compose - %s", string(output))
       return nil
   }
   
   func main() {
       if err := runCommand(); err != nil {
           log.Fatalf("Error: %v", err)
       }
   }

   With this approach, the child process won’t inherit stale environment variables, and Docker Compose will read your fresh .env file.

2. Unset or Remove Specific Variables

   Alternatively, if only a few variables are causing the issue, unset them in your Go program’s environment (using os.Unsetenv) before executing the command. This forces Docker Compose to apply the values from the .env file for those keys.

Additional Considerations

• Make sure you set the working directory (cmd.Dir) in case your docker-compose.yml and .env files are not in the current working directory of the Go process.
• It’s useful for development to use flags like --build so that Docker Compose rebuilds images when there are changes, as noted in the Docker documentation.

By explicitly controlling the environment passed to docker-compose, you can avoid the stale .env file variables issue and allow your service to reuse the function to handle new requests correctly.