Zero Trust Workload Connectivity

package main
import (
	"fmt"
	"io"
	"log"
	"github.com/openziti/sdk-golang/ziti"
)
func main() {
	const identityFile = "/secure/path/to/identity.json"
	const serviceName = "private-api"
	config, err := ziti.NewConfigFromFile(identityFile)
	if err != nil {
		log.Fatal(err)
	}
	ztx, err := ziti.NewContext(config)
	if err != nil {
		log.Fatal(err)
	}
	conn, err := ztx.Dial(serviceName)
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	_, _ = conn.Write([]byte(
		"GET /health HTTP/1.1\r\nHost: private-api\r\nConnection: close\r\n\r\n",
	))
	body, err := io.ReadAll(conn)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(string(body))
}

import org.openziti.Ziti;
import org.openziti.ZitiContext;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
public class ZitiClient {
    public static void main(String[] args) throws Exception {
        String identityFile = "/secure/path/to/identity.json";
        String serviceName = "private-api";
        ZitiContext ziti = Ziti.newContext(identityFile);
        try (Socket conn = ziti.open(serviceName);
             OutputStream out = conn.getOutputStream();
             InputStream in = conn.getInputStream()) {
            out.write((
                "GET /health HTTP/1.1\r\n" +
                "Host: private-api\r\n" +
                "Connection: close\r\n\r\n"
            ).getBytes(StandardCharsets.UTF_8));
            out.flush();
            System.out.print(new String(in.readAllBytes(), StandardCharsets.UTF_8));
        }
    }
}

import ziti from "@openziti/ziti-sdk-nodejs";
const identityFile = "/secure/path/to/identity.json";
const serviceName = "private-api";
await ziti.init(identityFile);
ziti.httpRequest(
  serviceName,
  undefined,                 // No conventional scheme/host/port
  "GET",
  "/health",
  ["Accept: application/json"],
  undefined,
  undefined,
  (response) => {
    console.log(response.body.toString("utf8"));
  }
);

using System;
using System.IO;
using System.Threading.Tasks;
using OpenZiti;
public class ZitiClient
{
    public static async Task Main()
    {
        const string identityFile = "/secure/path/to/identity.json";
        const string serviceName = "private-api";
        var ziti = await ZitiContext.Create(identityFile);
        using var connection = await ziti.Dial(serviceName);
        using var writer = new StreamWriter(connection) { AutoFlush = true };
        using var reader = new StreamReader(connection);
        await writer.WriteAsync(
            "GET /health HTTP/1.1\r\n" +
            "Host: private-api\r\n" +
            "Connection: close\r\n\r\n"
        );
        Console.WriteLine(await reader.ReadToEndAsync());
    }
}

#include <stdio.h>
#include <string.h>
#include <ziti/ziti.h>
static void on_connect(ziti_connection conn, int status) {
    if (status != ZITI_OK) {
        fprintf(stderr, "Ziti dial failed: %s\n", ziti_errorstr(status));
        return;
    }
    const char *request =
        "GET /health HTTP/1.1\r\n"
        "Host: private-api\r\n"
        "Connection: close\r\n\r\n";
    ziti_write(conn, (const uint8_t *)request, strlen(request), NULL, NULL);
}
int main(void) {
    const char *identity_file = "/secure/path/to/identity.json";
    const char *service_name = "private-api";
    ziti_context ztx;
    int rc = ziti_load_config(&ztx, identity_file);
    if (rc != ZITI_OK) {
        fprintf(stderr, "Could not load identity: %s\n", ziti_errorstr(rc));
        return 1;
    }
    ziti_connection conn;
    ziti_conn_init(ztx, &conn, NULL);
    ziti_dial(conn, service_name, on_connect, NULL);
    ziti_run(ztx);
    ziti_shutdown(ztx);
    return 0;
}

import Foundation
import Ziti
let identityFile = "/secure/path/to/identity.json"
let serviceName = "private-api"
let ziti = try ZitiContext(identity: identityFile)
let connection = try ziti.dial(serviceName)
let request = """
GET /health HTTP/1.1\r
Host: private-api\r
Connection: close\r
\r
"""
try connection.write(request.data(using: .utf8)!)
var response = Data()
while let chunk = try connection.read(maxLength: 4096), !chunk.isEmpty {
    response.append(chunk)
}
print(String(decoding: response, as: UTF8.self))
connection.close()