# Custom Envoy Bootstrap Configuration

This sample creates a simple helloworld service that bootstraps the Envoy proxy with a custom configuration file.

## Starting the service

First, we need to create a `ConfigMap` resource with our bootstrap configuration.

```bash
kubectl apply -f custom-bootstrap.yaml
```

Next, we can create a service that uses this bootstrap configuration.

            plugins {
                id "org.gradle.hello-world" version "0.2" //exits in the plugin portal
            }
        """
        use(repoA, repoB)

        when:
        fails("helloWorld")

        then:
        failure.assertThatDescription(containsNormalizedString("""
            - Plugin Repositories (could not resolve plugin artifact 'org.gradle.hello-world:org.gradle.hello-world.gradle.plugin:0.2')

It will also build `linux/amd64,linux/arm64` which you can override with `PLATFORMS`.

You can also build a set of images instead of all of them:

```bash
docker buildx bake --push examples-helloworld-v1 tcp-echo-server
```

## Updating images

When updating images, increment the version for the image in the `tags` config.
You will also want to update the sample YAMLs

## Building official images

import okhttp3.OkHttpClient
import okhttp3.Request

class SynchronousGet {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build()

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      for ((name, value) in response.headers) {

import okhttp3.Request
import okhttp3.Response

class AsynchronousGet {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    client.newCall(request).enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {

      .addNetworkInterceptor(CHECK_HANDSHAKE_INTERCEPTOR)
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

            }
        """

        and:
        useCustomRepository(PathType.ABSOLUTE)

        expect:
        fails("helloWorld")
        failure.assertHasDescription("Plugin [id: 'org.gradle.hello-world', version: '0.2'] was not found in any of the following sources:")
    }

          // 1 MiB.
          maxSize = 10L * 1024L * 1024L,
        ),
      )
      .build()

  fun run() {
    val request =
      Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    val response1Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

}"""
    }

    def goodCodeUsingJavaInterface() {
        file("src/main/scala/compile/test/Demo.scala") << """
            package compile.test

            object Demo {
              MyInterface.helloWorld();
            }
        """.stripIndent()
    }


    def goodJavaInterfaceCode() {
        file("src/main/java/compile/test/MyInterface.java") << """
            package compile.test;

                    attributes('Main-Class': 'driver.Driver')
                }
            }
        """

        when:
        succeeds taskName

        then:
        file("out.txt").text == """helloworld"""

        where:
        method                    | taskName
        'JavaExec task'           | 'runWithTask'
        'project.javaexec'        | 'runWithJavaExec'