Echo text to a file in golang

Is it possible to do something in Golang similar to the below in bash

GrafanaProvData()
{
cat > /etc/grafana/provisioning/datasources/datasource.yml << EOF
apiVersion: 1
deleteDatasources:
  - name: Clickhouse
    orgId: 1
datasources:
  - name: Clickhouse
    type: vertamedia-clickhouse-datasource
    access: proxy
    url: http://localhost:8123
    basicAuth: 1
    basicAuthUser: default
    basicAuthPassword: $password
    isDefault: false
    defaultDatabase:
EOF
}

i have tried command.exec but its not exactly what is needed

What happens in this shell script is the usage of the so-called "here document" which is piped by the shell to the standard input of the command cat whose standard output is directed to a file, which — due to the redirection set up using > — will be either created or truncated.

As commented by some folks, in Go, that would mostly amount to writing a string literal to a text file.

But note that there is a twist: when here-documents are processed by the shell it performs various expansions — including variable expansion — in the document's text before actually using it — unless special action is taken to prevent that.
So, in your example, the contents of the variable "password" would be substituted in place of $password.

With this in mind, what you'd do is something like

const tmpl = `apiVersion: 1
deleteDatasources:
  - name: Clickhouse
    orgId: 1
datasources:
  - name: Clickhouse
    type: vertamedia-clickhouse-datasource
    access: proxy
    url: http://localhost:8123
    basicAuth: 1
    basicAuthUser: default
    basicAuthPassword: %s
    isDefault: false
    defaultDatabase:
`
fd, err := os.OpenFile("/etc/grafana/provisioning/datasources/datasource.yml",
os.O_WRONLY|os.O_TRUNC, 0666)
if err != nil {
  log.Fatal(err)
}
defer fd.Close()
_, err := fmt.Fprintf(tmpl, password)
if err != nil {
  log.Fatal(err)
}

While we are at it, consider two more things:

• If/when the template becomes more complicated, it would become progressively harder to use the functions of the fmt.*f family to cut the task; you then might want to look at the text/template standard package.
• If/when you would need even more advanced processing of your YAML templates, it might be more convenient to stop being format-agnostic and use any YAML-handling package for Go — such as the venerable gopkg.in/yaml.v3 to first fill a variable of some custom compound type and then marshal it as a YAML-formatted document.
  This might help prevent a certain class of weird erorrs (consider: what happens if your password contains letters which will be interpreted by a YAML parser as a proper YAML syntax? A "real" YAML marshaler would escape anything which would be improperly interpreted — while any "templating" approach would not.)

One more hint: when the file to be written is big (like, over 10k), it might be worthwhile to stick a bufio.Writer between the fmt.Fprint* functions and the opened file—to optimize filesystem access.