Configuration and Authentication

/**
 * Main configuration class for Kubernetes cluster access
 */
class KubeConfig {
  /** Load configuration from default locations (kubeconfig file, environment, in-cluster) */
  loadFromDefault(options?: Partial<ConfigOptions>): void;
  
  /** Load configuration from a specific kubeconfig file */
  loadFromFile(file: string, opts?: Partial<ConfigOptions>): void;
  
  /** Load configuration from a YAML string */
  loadFromString(config: string, opts?: Partial<ConfigOptions>): void;
  
  /** Load in-cluster service account configuration */
  loadFromCluster(): void;
  
  /** Load configuration from options object */
  loadFromOptions(options: any): void;
  
  /** Create a typed API client instance */
  makeApiClient<T>(apiClientType: ApiType<T>): T;
  
  /** Apply authentication to HTTPS request options */
  applyToHTTPSOptions(opts: https.RequestOptions | WebSocket.ClientOptions): Promise<void>;
  
  /** Apply authentication to fetch options */
  applyToFetchOptions(opts: https.RequestOptions): Promise<RequestInit>;
  
  /** Available clusters */
  clusters: Cluster[];
  
  /** Available users */
  users: User[];
  
  /** Available contexts */
  contexts: Context[];
  
  /** Active context name */
  currentContext: string;
  
  /** Get all contexts */
  getContexts(): Context[];
  
  /** Get all clusters */
  getClusters(): Cluster[];
  
  /** Get all users */
  getUsers(): User[];
  
  /** Get current context name */
  getCurrentContext(): string;
  
  /** Set current context */
  setCurrentContext(context: string): void;
  
  /** Get context object by name */
  getContextObject(name: string): Context | null;
  
  /** Get current cluster */
  getCurrentCluster(): Cluster | null;
  
  /** Get cluster by name */
  getCluster(name: string): Cluster | null;
  
  /** Get current user */
  getCurrentUser(): User | null;
  
  /** Get user by name */
  getUser(name: string): User | null;
}

import { KubeConfig, CoreV1Api } from '@kubernetes/client-node';

// Load from default location
const kc = new KubeConfig();
kc.loadFromDefault();

// Load from specific file
kc.loadFromFile('/path/to/kubeconfig');

// Load from YAML string
const yamlConfig = `
apiVersion: v1
clusters:
- cluster:
    server: https://k8s.example.com
  name: my-cluster
contexts:
- context:
    cluster: my-cluster
    user: my-user
  name: my-context
current-context: my-context
users:
- name: my-user
  user:
    token: my-token
`;
kc.loadFromString(yamlConfig);

// Load in-cluster config (for pods running in Kubernetes)
kc.loadFromCluster();

// Create API client
const k8sApi = kc.makeApiClient(CoreV1Api);

interface ConfigOptions {
  /** How to handle invalid configuration entries */
  onInvalidEntry: ActionOnInvalid;
}

interface Cluster {
  /** Cluster name */
  name: string;
  /** API server URL */
  server: string;
  /** Certificate authority data (base64) */
  caData?: string;
  /** Certificate authority file path */
  caFile?: string;
  /** TLS server name for SNI */
  tlsServerName?: string;
  /** Skip TLS verification */
  skipTLSVerify: boolean;
  /** Proxy URL for cluster access */
  proxyUrl?: string;
}

interface User {
  /** User name */
  name: string;
  /** Authentication token */
  token?: string;
  /** Client certificate data (base64) */
  certData?: string;
  /** Client certificate file path */
  certFile?: string;
  /** Client key data (base64) */
  keyData?: string;
  /** Client key file path */
  keyFile?: string;
  /** Username for basic auth */
  username?: string;
  /** Password for basic auth */
  password?: string;
  /** Authentication provider configuration */
  authProvider?: any;
  /** Exec credential configuration */
  exec?: any;
  /** Impersonate user */
  impersonateUser?: string;
}

interface Context {
  /** Context name */
  name: string;
  /** Cluster name to use */
  cluster: string;
  /** User name to use */
  user: string;
  /** Default namespace */
  namespace?: string;
}

const ActionOnInvalid = {
  THROW: 'throw',
  FILTER: 'filter'
} as const;

type ActionOnInvalid = typeof ActionOnInvalid[keyof typeof ActionOnInvalid];

/**
 * Create cluster array from configuration data
 */
function newClusters(a: any, opts?: Partial<ConfigOptions>): Cluster[];

/**
 * Create user array from configuration data
 */
function newUsers(a: any, opts?: Partial<ConfigOptions>): User[];

/**
 * Create context array from configuration data
 */
function newContexts(a: any, opts?: Partial<ConfigOptions>): Context[];

/**
 * Export cluster to configuration format
 */
function exportCluster(cluster: Cluster): any;

/**
 * Export user to configuration format
 */
function exportUser(user: User): any;

/**
 * Export context to configuration format
 */
function exportContext(context: Context): any;

/**
 * Make an absolute file path
 */
function makeAbsolutePath(root: string, file: string): string;

/**
 * Load buffer from file or string
 */
function bufferFromFileOrString(file?: string, data?: string): Buffer | null;

/**
 * Find user home directory
 */
function findHomeDir(platform?: string): string | null;

/**
 * Find named object in list
 */
function findObject<T>(list: T[], name: string, key: string): T | null;

interface Authenticator {
  /** Check if this authenticator handles the user configuration */
  isAuthProvider(user: User): boolean;
  
  /** Apply authentication to request options */
  applyAuthentication(user: User, opts: any): Promise<void>;
}

import { KubeConfig, GoogleCloudPlatformAuth } from '@kubernetes/client-node';

const kc = new KubeConfig();
kc.loadFromDefault();

// Authentication is automatically handled when making API calls
const k8sApi = kc.makeApiClient(CoreV1Api);
const pods = await k8sApi.listNamespacedPod('default');

import { KubeConfig } from '@kubernetes/client-node';

// This loads the service account token and CA certificate
// from the standard locations: /var/run/secrets/kubernetes.io/serviceaccount/
const kc = new KubeConfig();
kc.loadFromCluster();

const k8sApi = kc.makeApiClient(CoreV1Api);

import { KubeConfig } from '@kubernetes/client-node';

try {
  const kc = new KubeConfig();
  kc.loadFromFile('/invalid/path/kubeconfig');
} catch (error) {
  console.error('Configuration error:', error.message);
}

const kc = new KubeConfig();
kc.loadFromDefault();

// Switch between contexts
kc.currentContext = 'production-cluster';
const prodApi = kc.makeApiClient(CoreV1Api);

kc.currentContext = 'staging-cluster';
const stagingApi = kc.makeApiClient(CoreV1Api);

const kc = new KubeConfig();
kc.loadFromOptions({
  clusters: [{
    name: 'my-cluster',
    server: 'https://k8s.example.com',
    skipTLSVerify: false
  }],
  users: [{
    name: 'my-user',
    token: 'bearer-token-here'
  }],
  contexts: [{
    name: 'my-context',
    cluster: 'my-cluster',
    user: 'my-user',
    namespace: 'my-namespace'
  }],
  currentContext: 'my-context'
});