如何不依赖第三方库用Java通过文件夹创建Kubernetes ConfigMap？

You don't need any third-party libraries—Java's standard library has everything you need to replicate the kubectl create configmap configmap2 --from-file foldername behavior by interacting directly with the Kubernetes API. Here's how to pull it off:

Step 1: Understand What the kubectl Command Does #

When you run that kubectl command, it under the hood:

• Scans every file in your target folder
• Creates a key-value pair for each file (filename as the key, file content as the value)
• Sends a POST request to the Kubernetes API endpoint /api/v1/namespaces/{namespace}/configmaps with a JSON payload defining the ConfigMap

Step 2: Read Files from the Target Folder #

First, we'll write code to read all files in the folder and build our key-value map using Java's core java.io classes:

import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class ConfigMapCreator {
    private static Map<String, String> readFolderContents(String folderPath) throws IOException {
        Map<String, String> fileContents = new HashMap<>();
        File folder = new File(folderPath);
        
        if (!folder.isDirectory()) {
            throw new IllegalArgumentException("Path is not a directory: " + folderPath);
        }
        
        File[] files = folder.listFiles();
        if (files == null) {
            return fileContents;
        }
        
        for (File file : files) {
            if (file.isFile()) {
                StringBuilder contentBuilder = new StringBuilder();
                try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        contentBuilder.append(line).append("\n");
                    }
                    // Remove trailing newline to match kubectl's behavior
                    if (contentBuilder.length() > 0) {
                        contentBuilder.setLength(contentBuilder.length() - 1);
                    }
                    fileContents.put(file.getName(), contentBuilder.toString());
                }
            }
        }
        return fileContents;
    }
}

Step 3: Build the ConfigMap JSON Payload #

Since we can't use third-party JSON libraries, we'll manually construct the JSON string. We need to escape special characters like quotes and newlines to avoid invalid JSON:

private static String buildConfigMapJson(String configMapName, Map<String, String> data, String namespace) {
    StringBuilder jsonBuilder = new StringBuilder();
    jsonBuilder.append("{")
               .append("\"apiVersion\": \"v1\",")
               .append("\"kind\": \"ConfigMap\",")
               .append("\"metadata\": {")
               .append("\"name\": \"").append(escapeJson(configMapName)).append("\",")
               .append("\"namespace\": \"").append(escapeJson(namespace)).append("\"")
               .append("},")
               .append("\"data\": {");
    
    boolean firstEntry = true;
    for (Map.Entry<String, String> entry : data.entrySet()) {
        if (!firstEntry) {
            jsonBuilder.append(",");
        }
        jsonBuilder.append("\"").append(escapeJson(entry.getKey())).append("\": \"")
                   .append(escapeJson(entry.getValue())).append("\"");
        firstEntry = false;
    }
    
    jsonBuilder.append("}}");
    return jsonBuilder.toString();
}

// Helper to escape JSON special characters
private static String escapeJson(String input) {
    if (input == null) {
        return "";
    }
    return input.replace("\\", "\\\\")
                .replace("\"", "\\\"")
                .replace("\n", "\\n")
                .replace("\r", "\\r")
                .replace("\t", "\\t");
}

Step 4: Send the HTTP Request to Kubernetes API #

We'll use java.net.HttpURLConnection to send the POST request. You'll need a bearer token for authentication—you can grab this from your ~/.kube/config file, or use the service account token if running inside a Kubernetes pod:

private static void sendCreateRequest(String apiUrl, String jsonPayload, String bearerToken) throws IOException {
    URL url = new URL(apiUrl);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    
    try {
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/json");
        connection.setRequestProperty("Authorization", "Bearer " + bearerToken);
        connection.setDoOutput(true);
        
        // Write JSON payload to request body
        try (OutputStream os = connection.getOutputStream()) {
            byte[] input = jsonPayload.getBytes("UTF-8");
            os.write(input, 0, input.length);
        }
        
        // Handle response
        int responseCode = connection.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_CREATED) {
            System.out.println("ConfigMap created successfully!");
            // Optional: Print full response
            try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"))) {
                StringBuilder response = new StringBuilder();
                String line;
                while ((line = br.readLine()) != null) {
                    response.append(line.trim());
                }
                System.out.println("API Response: " + response);
            }
        } else {
            System.err.println("Failed to create ConfigMap. Response code: " + responseCode);
            // Print error details
            try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getErrorStream(), "UTF-8"))) {
                StringBuilder error = new StringBuilder();
                String line;
                while ((line = br.readLine()) != null) {
                    error.append(line.trim());
                }
                System.err.println("Error Details: " + error);
            }
        }
    } finally {
        connection.disconnect();
    }
}

Step 5: Put It All Together #

Here's the main method to tie everything into a working script:

public static void main(String[] args) {
    try {
        // Configure your values here
        String configMapName = "configmap2";
        String folderPath = "./foldername"; // Replace with your folder path
        String namespace = "default"; // Replace with your target namespace
        String k8sApiUrl = "https://your-k8s-api-server:6443/api/v1/namespaces/" + namespace + "/configmaps"; // Replace with your API URL
        String bearerToken = "your-bearer-token-here"; // Replace with your token
        
        // Read folder contents
        Map<String, String> fileData = readFolderContents(folderPath);
        
        // Build JSON payload
        String jsonPayload = buildConfigMapJson(configMapName, fileData, namespace);
        
        // Send creation request
        sendCreateRequest(k8sApiUrl, jsonPayload, bearerToken);
        
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Key Notes #

• In-Cluster Authentication: If running inside a Kubernetes pod, you can use the auto-mounted service account token at /var/run/secrets/kubernetes.io/serviceaccount/token and CA cert at /var/run/secrets/kubernetes.io/serviceaccount/ca.crt for secure connections.
• RBAC Permissions: Make sure the account running the Java app has the create permission for ConfigMaps in the target namespace.
• Edge Cases: The escapeJson method handles basic scenarios—you might want to expand it for control characters if your files have complex content.

内容的提问来源于stack exchange，提问作者vidya k.s.