K3sContainer: expose kubeConfig for docker network access

modules/k3s/src/main/java/org/testcontainers/k3s/K3sContainer.java

@@ -5,7 +5,6 @@
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.fasterxml.jackson.databind.node.TextNode;
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
-import com.github.dockerjava.api.command.InspectContainerResponse;
 import com.github.dockerjava.api.model.DockerObjectAccessor;
 import lombok.SneakyThrows;
 import org.testcontainers.containers.BindMode;
@@ -18,13 +17,16 @@
 
 public class K3sContainer extends GenericContainer<K3sContainer> {
 
-    private String kubeConfigYaml;
+    public static int KUBE_SECURE_PORT = 6443;
+
+    public static int RANCHER_WEBHOOK_PORT = 8443;
+
 
     public K3sContainer(DockerImageName dockerImageName) {
         super(dockerImageName);
         dockerImageName.assertCompatibleWith(DockerImageName.parse("rancher/k3s"));
 
-        addExposedPorts(6443, 8443);
+        addExposedPorts(KUBE_SECURE_PORT, RANCHER_WEBHOOK_PORT);
         setPrivilegedMode(true);
         withCreateContainerCmdModifier(it -> {
             DockerObjectAccessor.overrideRawValue(
@@ -47,8 +49,8 @@ public K3sContainer(DockerImageName dockerImageName) {
     }
 
     @SneakyThrows
-    @Override
-    protected void containerIsStarted(InspectContainerResponse containerInfo) {
+    public String getKubeConfigYaml(String networkAlias) {
+
         ObjectMapper objectMapper = new ObjectMapper(new YAMLFactory());
 
         ObjectNode rawKubeConfig = copyFileFromContainer(
@@ -61,15 +63,26 @@ protected void containerIsStarted(InspectContainerResponse containerInfo) {
             throw new IllegalStateException("'/clusters/0/cluster' expected to be an object");
         }
         ObjectNode clusterConfig = (ObjectNode) clusterNode;
-
-        clusterConfig.replace("server", new TextNode("https://" + this.getHost() + ":" + this.getMappedPort(6443)));
+        String serverUrl = resolveServerUrl(networkAlias);
+        clusterConfig.replace("server", new TextNode(serverUrl));
 
         rawKubeConfig.set("current-context", new TextNode("default"));
 
-        kubeConfigYaml = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(rawKubeConfig);
+        return objectMapper.writerWithDefaultPrettyPrinter()
+            .writeValueAsString(rawKubeConfig);
     }
 
     public String getKubeConfigYaml() {
-        return kubeConfigYaml;
+        return getKubeConfigYaml(this.getHost());
+    }
+
+    private String resolveServerUrl(String networkAlias) {
+        if (networkAlias.equals(this.getHost())) {
+            return "https://" + this.getHost() + ":" + this.getMappedPort(KUBE_SECURE_PORT);
+        } else if (this.getNetworkAliases().contains(networkAlias)) {
+            return "https://" + networkAlias + ":" + KUBE_SECURE_PORT;
+        } else {
+            throw new IllegalArgumentException(networkAlias + " is not a network alias for k3s container");
+        }
     }
 }

modules/k3s/src/test/java/org/testcontainers/k3s/KubectlContainerTest.java

@@ -0,0 +1,66 @@
+package org.testcontainers.k3s;
+
+import lombok.extern.slf4j.Slf4j;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+import org.testcontainers.containers.output.WaitingConsumer;
+import org.testcontainers.utility.DockerImageName;
+import org.testcontainers.utility.MountableFile;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.TimeUnit;
+
+import static org.testcontainers.containers.Network.newNetwork;
+import static org.testcontainers.containers.output.OutputFrame.OutputType.STDOUT;
+
+@Slf4j
+public class KubectlContainerTest {
+
+    public static Network network = newNetwork();
+
+    public static K3sContainer k3s = new K3sContainer(DockerImageName.parse("rancher/k3s:v1.21.3-k3s1"))
+        .withNetwork(network)
+        .withNetworkAliases("k3s");
+
+    @BeforeClass
+    public static void setup() {
+        k3s.start();
+    }
+
+    @AfterClass
+    public static void tearDown() {
+        k3s.stop();
+    }
+
+    @Test
+    public void shouldExposeKubeConfigForNetworkAlias() throws Exception {
+
+        String kubeConfigYaml = k3s.getKubeConfigYaml("k3s");
+
+        Path tempFile = Files.createTempFile(null, null);
+        Files.write(tempFile, kubeConfigYaml.getBytes(StandardCharsets.UTF_8));
+
+        GenericContainer<?> kubectlContainer = new GenericContainer<>(DockerImageName.parse("rancher/kubectl:v1.23.3"))
+            .withNetwork(network)
+            .withCopyFileToContainer(MountableFile.forHostPath(tempFile.toAbsolutePath()), "/.kube/config")
+            .withCommand("get namespaces");
+
+        kubectlContainer.start();
+
+        WaitingConsumer consumer = new WaitingConsumer();
+        kubectlContainer.followOutput(consumer, STDOUT);
+
+        consumer.waitUntil(frame ->
+            frame.getUtf8String().contains("kube-system"), 30, TimeUnit.SECONDS);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void shouldThrowAnExceptionForUnknownNetworkAlias() {
+        k3s.getKubeConfigYaml("not-set-network-alias");
+    }
+}