kjuulh/dagger
Archived
1
0
Fork 0
Code Issues 1 Pull Requests 1 Projects Releases Wiki Activity

Improve go use case example according to Gerhard's review

Browse Source 
Signed-off-by: Vasek - Tom C <tom.chauveau@epitech.eu>
This commit is contained in:
Tom Chauveau 2022-03-17 14:55:34 +01:00 committed by Vasek - Tom C
parent 2d3acc61e0
commit 6fe49a0294
No known key found for this signature in database
GPG Key ID: 175D82E572427960
10 changed files with 167 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
docs/tests/use-cases/ci-cd-for-go-project/base.cue.fragment Normal file
View File

@ -0,0 +1,14 @@
import (
"dagger.io/dagger"
"universe.dagger.io/go"
)
dagger.#Plan & {
actions: {
// Improve go base image with useful tool
// Enable cgo by installing build-base
_base: go.#Image & {
packages: "build-base": version: _
}
}
}

4
docs/tests/use-cases/ci-cd-for-go-project/build.cue.fragment Normal file
View File

@ -0,0 +1,4 @@
// Build go project
build: go.#Build & {
source: _code
}

32
docs/tests/use-cases/ci-cd-for-go-project/build/dagger.cue
View File

@ -1,32 +0,0 @@
package main
import (
"dagger.io/dagger"
"universe.dagger.io/go"
)
dagger.#Plan & {
client: {
// Retrieve go source code
filesystem: ".": read: {
contents: dagger.#FS
include: ["go.mod", "go.sum", "**/*.go"]
}
}
actions: {
// Alias to code directory
_code: client.filesystem.".".read.contents
// Improved go base image with useful tool
// Enable cgo by installing build-base
_base: go.#Image & {
packages: "build-base": version: _
}
// Build go project
build: go.#Build & {
source: _code
}
}
}

23
docs/tests/use-cases/ci-cd-for-go-project/push/dagger.cue → docs/tests/use-cases/ci-cd-for-go-project/complete-ci-cd/dagger.cue
View File

@ -9,13 +9,11 @@ import (
dagger.#Plan & {
client: {
// Retrieve go source code
filesystem: ".": read: {
contents: dagger.#FS
include: ["go.mod", "go.sum", "**/*.go"]
}
// Retrieve docker password from environment
env: DOCKER_PASSWORD: dagger.#Secret
}
@ -23,9 +21,20 @@ dagger.#Plan & {
// Alias to code
_code: client.filesystem.".".read.contents
// Improved go base image with useful tool
// Improve go base image with useful tool
// Enable cgo by installing build-base
_base: go.#Image & {
packages: "build-base": version: _
packages: {
"build-base": version: _
bash: version: _
}
}
// Run go unit test
"unit-test": go.#Test & {
source: _code
package: "./..."
input: _base.output
}
// Build go project
@ -45,7 +54,7 @@ dagger.#Plan & {
dest: "/usr/bin"
},
docker.#Set & {
config: cmd: ["/<path>/<to>/<your>/<binary>"]
config: cmd: ["<path/to/binary>"]
},
]
}
@ -54,11 +63,11 @@ dagger.#Plan & {
// Push image to remote registry (depends on image)
push: {
// Docker username
_dockerUsername: "<docker username>"
_dockerUsername: "<my_username>"
docker.#Push & {
"image": image.output
dest: "\(_dockerUsername)/<repository>:<tag>"
dest: "\(_dockerUsername)/<my_repository>"
auth: {
username: "\(_dockerUsername)"
secret: client.env.DOCKER_PASSWORD

22
docs/tests/use-cases/ci-cd-for-go-project/image.cue.fragment Normal file
View File

@ -0,0 +1,22 @@
import (
"universe.dagger.io/alpine"
"universe.dagger.io/docker"
)
// Build docker image (depends on build)
image: {
_base: alpine.#Build & {}
docker.#Build & {
steps: [
docker.#Copy & {
input: _base.output
contents: build.output
dest: "/usr/bin"
},
docker.#Set & {
config: cmd: ["</path/to/binary>"]
},
]
}
}

14
docs/tests/use-cases/ci-cd-for-go-project/push.cue.fragment Normal file
View File

@ -0,0 +1,14 @@
// Push image to remote registry (depends on image)
push: {
// Docker username
_dockerUsername: "<my_username>"
docker.#Push & {
"image": image.output
dest: "\(_dockerUsername)/<my_repository>"
auth: {
username: "\(_dockerUsername)"
secret: client.env.DOCKER_PASSWORD
}
}
}

18
docs/tests/use-cases/ci-cd-for-go-project/retrieve-go-project/dagger.cue Normal file
View File

@ -0,0 +1,18 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
// Retrieve go source code
client: filesystem: ".": read: {
contents: dagger.#FS
include: ["go.mod", "go.sum", "**/*.go"]
}
actions: {
// Alias to code directory
_code: client.filesystem.".".read.contents
}
}

6
docs/tests/use-cases/ci-cd-for-go-project/test.cue.fragment Normal file
View File

@ -0,0 +1,6 @@
// Run go unit test
"unit-test": go.#Test & {
source: _code
package: "./..."
input: _base.output
}

34
docs/tests/use-cases/ci-cd-for-go-project/test/dagger.cue
View File

@ -1,34 +0,0 @@
package main
import (
"dagger.io/dagger"
"universe.dagger.io/go"
)
dagger.#Plan & {
client: {
// Retrieve go source code
filesystem: ".": read: {
contents: dagger.#FS
include: ["go.mod", "go.sum", "**/*.go"]
}
}
actions: {
// Alias to code directory
_code: client.filesystem.".".read.contents
// Improved go base image with useful tool
// Enable cgo by installing build-base
_base: go.#Image & {
packages: "build-base": version: _
}
// Run go unit test
"unit-test": go.#Test & {
source: _code
package: "./..."
input: _base.output
}
}
}

90
docs/use-cases/1216-go-on-docker-hub.md
View File

@ -14,48 +14,104 @@ to control the whole CI/CD process, from test to push into a remote registry.
Following examples can be used as a template for any standalone go project.
:::
## Test
## Retrieve Go project
```cue file=../tests/use-cases/ci-cd-for-go-project/test/dagger.cue
First important step is to make go project accessible in dagger plan.
You can indeed choose which files to include in the filesystem.
Since it's a Golang project, filesystem should contain module and every go
source files:
```cue file=../tests/use-cases/ci-cd-for-go-project/retrieve-go-project/dagger.cue
```
You can then run unit test in your go project with
:::tip
To make it more accessible in actions, you can set a private field that will
act as an alias.
:::
```shell
dagger do unit-test
## Build a Go base image
[Dagger go universe](https://github.com/dagger/dagger/tree/main/pkg/universe.dagger.io/go)
provide a [base image](https://github.com/dagger/dagger/blob/main/pkg/universe.dagger.io/go/image.cue)
to build your pipeline but your project may use `CGO` or any external dependencies.
You can customize that base image to install required dependencies:
```cue file=../tests/use-cases/ci-cd-for-go-project/base.cue.fragment
```
<!-- FIXME: we should write a bunch of documentation about TDD with dagger -->
## Run unit test
Before deliver your application, you certainly want to run unit test.
By using previous steps, you can use the [test](https://github.com/dagger/dagger/blob/main/pkg/universe.dagger.io/go/test.cue)
definition to run your unit test:
```cue file=../tests/use-cases/ci-cd-for-go-project/test.cue.fragment
```
<!-- FIXME(TomChv): we should write a bunch of documentation about TDD with dagger -->
:::tip
You can also use dagger to write integration tests
:::
## Build
## Build Go binary
```cue file=../tests/use-cases/ci-cd-for-go-project/build/dagger.cue
To put your go project on docker hub, you first need to compile a binary.
Go universe expose a [build](https://github.com/dagger/dagger/blob/main/pkg/universe.dagger.io/go/build.cue)
definition so you can build a binary:
```cue file=../tests/use-cases/ci-cd-for-go-project/build.cue.fragment
```
:::tip
You can control the binary platform with `os` and `arch` field.
:::
You can then build your binary with
## Prepare docker image
```shell
dagger do build
To make it usable by other user, you must put your binary in an image and set an entrypoint.
For optimisation purpose, you can use alpine as base image to contain your binary:
```cue file=../tests/use-cases/ci-cd-for-go-project/image.cue.fragment
```
## Push
## Push to Docker Hub
```cue file=../tests/use-cases/ci-cd-for-go-project/push/dagger.cue
To push an image to docker hub, you will need to forward credential to allow
dagger push.
To not hard code your docker password in the plan, you can retrieve it as an
environment value:
```cue
dagger.#Plan & {
client: {
// ...
env: DOCKER_PASSWORD: dagger.#Secret
}
}
```
You can then build and push your go project with
You can now push your image:
```shell
dagger do push
```cue file=../tests/use-cases/ci-cd-for-go-project/push.cue.fragment
```
## Complete CI/CD
After merging all examples, you will have a complete CI/CD to deliver a go
binary on Docker Hub.
```cue file=../tests/use-cases/ci-cd-for-go-project/complete-ci-cd/dagger.cue
```
You can then use `dagger do` to select which action you want to run.
## Push multi-platform
Coming soon
Coming soon...