/// <summary>
/// Adds the <see cref="KubernetesClient"/> to the specified <see cref="IServiceCollection"/>.
/// </summary>
/// <param name="services">
/// The <see cref="IServiceCollection"/> to add services to.
/// </param>
/// <param name="namespace">
/// The namespace in which to operate. The default value is <c>default</c>.
/// </param>
/// <returns>
/// The <see cref="IServiceCollection"/> so that additional calls can be chained.
/// </returns>
public static IServiceCollection AddKubernetes(this IServiceCollection services, string @namespace = "default")
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (@namespace == null)
{
throw new ArgumentNullException(nameof(@namespace));
}
services.AddSingleton <KubernetesClientConfiguration>(KubernetesClientConfiguration.BuildDefaultConfig());
services.AddSingleton <IKubernetesProtocol, KubernetesProtocol>();
services.AddSingleton <KubernetesClient>();
services.AddScoped <KubernetesDeveloperProfile>();
services.AddSingleton(new ImageRegistryClientConfiguration("kaponata-registry", 5000));
services.AddScoped <ImageRegistryClientFactory>();
services.AddSingleton <DeveloperDiskFactory>();
services.AddScoped <DeveloperDiskStore, RegistryDeveloperDiskStore>();
services.AddScoped <LicenseStore>();
services.AddOptions <KubernetesOptions>().Configure(c => c.Namespace = @namespace);
return(services);
}
public async Task Invoke(HttpContext httpContext)
{
if (AuthenticationHeaderValue.TryParse(httpContext.Request.Headers["Authorization"], out var auth) &&
string.Equals(auth.Scheme, "Bearer", StringComparison.OrdinalIgnoreCase))
{
using var kubernetes = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
var tokenReview = await kubernetes.CreateTokenReviewAsync(
new V1TokenReview(
new V1TokenReviewSpec(token: auth.Parameter)));
if (tokenReview.Status.Authenticated.GetValueOrDefault())
{
var identity = new ClaimsIdentity("Kubernetes");
identity.AddClaim(new Claim(identity.NameClaimType, tokenReview.Status.User.Username));
foreach (var group in tokenReview.Status.User.Groups)
{
identity.AddClaim(new Claim(identity.RoleClaimType, group));
}
httpContext.User = new ClaimsPrincipal(identity);
}
}
await next.Invoke(httpContext);
}
public static void Main(string[] args)
{
var config = KubernetesClientConfiguration.BuildDefaultConfig();
IKubernetes client = new Kubernetes(config);
var cts = new CancellationTokenSource();
_genericKubernetesApi = new GenericKubernetesApi(
apiGroup: "pod",
apiVersion: "v1",
resourcePlural: "pods",
apiClient: client);
var aPod = GetNamespacedPod(Namespaces.NamespaceDefault, "my-pod-name", cts.Token);
var aListOfPods = ListPodsInNamespace(Namespaces.NamespaceDefault, cts.Token);
// Watch for pod actions in a namespsace
using var watch = _genericKubernetesApi.Watch <V1Pod>(
Namespaces.NamespaceDefault,
(eventType, pod) => { Console.WriteLine("The event {0} happened on pod named {1}", eventType, pod.Metadata.Name); },
exception => { Console.WriteLine("Oh no! An exception happened while watching pods. The message was '{0}'.", exception.Message); },
() => { Console.WriteLine("The server closed the connection."); });
Console.WriteLine("press ctrl + c to stop watching");
var ctrlc = new ManualResetEventSlim(false);
Console.CancelKeyPress += (sender, eventArgs) => ctrlc.Set();
ctrlc.Wait();
cts.Cancel();
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericKubernetesApi"/> class.
/// </summary>
/// <param name="apiGroup"> the api group"></param>
/// <param name="apiVersion"> the api version"></param>
/// <param name="resourcePlural"> the resource plural, e.g. "jobs""></param>
/// <param name="apiClient"> optional client"></param>
public GenericKubernetesApi(string apiGroup = default, string apiVersion = default, string resourcePlural = default, IKubernetes apiClient = default)
{
_apiGroup = apiGroup ?? throw new ArgumentNullException(nameof(apiGroup));
_apiVersion = apiVersion ?? throw new ArgumentNullException(nameof(apiVersion));
_resourcePlural = resourcePlural ?? throw new ArgumentNullException(nameof(resourcePlural));
_client = apiClient ?? new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
}
public async Task Usbmuxd_CanListDevices_Async()
{
var config = KubernetesClientConfiguration.BuildDefaultConfig();
if (config.Namespace == null)
{
config.Namespace = "default";
}
using (var kubernetes = new KubernetesProtocol(
config,
this.loggerFactory.CreateLogger <KubernetesProtocol>(),
this.loggerFactory))
using (var client = new KubernetesClient(
kubernetes,
KubernetesOptions.Default,
this.output.BuildLoggerFor <KubernetesClient>(),
this.loggerFactory))
{
// There's at least one usbmuxd pod
var pods = await kubernetes.ListNamespacedPodAsync(config.Namespace, labelSelector : "app.kubernetes.io/component=usbmuxd");
Assert.NotEmpty(pods.Items);
var pod = pods.Items[0];
// The pod is in the running state
pod = await client.WaitForPodRunningAsync(pod, TimeSpan.FromMinutes(2), default).ConfigureAwait(false);
Assert.Equal("Running", pod.Status.Phase);
// We can connect to port 27015 and retrieve an empty device list
var locator = new KubernetesMuxerSocketLocator(kubernetes, pod, this.loggerFactory.CreateLogger <KubernetesMuxerSocketLocator>(), this.loggerFactory);
var muxerClient = new MuxerClient(locator, this.loggerFactory.CreateLogger <MuxerClient>(), this.loggerFactory);
var devices = await muxerClient.ListDevicesAsync(default).ConfigureAwait(false);
public static IKubernetes GetKubernetesClient(KubernetesApplicationOptions appInfo, Action <KubernetesClientConfiguration> kubernetesClientConfiguration = null, ILogger logger = null)
{
KubernetesClientConfiguration k8sConfig = null;
try
{
if (appInfo.Config.Paths.Any())
{
var delimiter = Platform.IsWindows ? ';' : ':';
var joinedPaths = appInfo.Config.Paths.Aggregate((i, j) => i + delimiter + j);
Environment.SetEnvironmentVariable("KUBECONFIG", joinedPaths);
}
k8sConfig = KubernetesClientConfiguration.BuildDefaultConfig();
}
catch (KubeConfigException e)
{
// couldn't locate .kube\config or user-identified files. use an empty config object and fall back on user-defined Action to set the configuration
logger?.LogWarning(e, "Failed to build KubernetesClientConfiguration, creating an empty config...");
}
// BuildDefaultConfig() doesn't set a host if KubeConfigException is thrown
k8sConfig ??= new KubernetesClientConfiguration()
{
Host = "http://localhost:8080"
};
kubernetesClientConfiguration?.Invoke(k8sConfig);
return(new k8s.Kubernetes(k8sConfig));
}
public async Task Create_Delete_KamusSecret()
{
await DeployController();
var kubernetes = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
var watch = await kubernetes.WatchNamespacedSecretAsync("my-tls-secret", "default");
var subject = new Subject <(WatchEventType, V1Secret)>();
watch.OnClosed += () => subject.OnCompleted();
watch.OnError += e => subject.OnError(e);
watch.OnEvent += (e, s) => subject.OnNext((e, s));
RunKubectlCommand("apply -f tls.yaml");
Console.WriteLine("Waiting for secret creation");
var tupple = await subject
.Where(t => t.Item1 == WatchEventType.Added).Timeout(TimeSpan.FromSeconds(30)).FirstAsync();
Assert.Equal("TlsSecret", tupple.Item2.Type);
Assert.Equal(true, tupple.Item2.Data.ContainsKey("key"));
Assert.Equal("hello", Encoding.UTF8.GetString(tupple.Item2.Data["key"]));
RunKubectlCommand("delete -f tls.yaml");
Console.WriteLine("Waiting for secret deletion");
await subject.Where(t => t.Item1 == WatchEventType.Deleted).Timeout(TimeSpan.FromSeconds(30)).FirstAsync();
}
public void SetPluginConfiguration(Dictionary <string, string> configuration)
{
KubernetesClientConfiguration config = null;
if (configuration != null)
{
_configuration = configuration;
config = configuration.ContainsKey(_configFilePathName)
? KubernetesClientConfiguration.BuildConfigFromConfigFile(configuration[_configFilePathName])
: KubernetesClientConfiguration.BuildDefaultConfig();
}
else
{
config = KubernetesClientConfiguration.BuildDefaultConfig();
}
if (config != null)
{
_client = new Kubernetes(config);
}
else
{
_logger.Error("Some parameters are missing from the configuration or the configuration file is invalid.");
}
}
public async Task <string> DeleteAll()
{
ApplicationDbContext c = _context;
var k8SClientConfig = KubernetesClientConfiguration.BuildDefaultConfig();
var client = new Kubernetes(k8SClientConfig);
var users = from a in c.Users
select a.Id;
var deplist = client.ListDeploymentForAllNamespaces();
var namelist = new HashSet <string>();
foreach (var deployment in deplist.Items)
{
if (users.Contains(deployment.Metadata.NamespaceProperty) && namelist.Contains(deployment.Metadata.NamespaceProperty) == false)
{
namelist.Add(deployment.Metadata.NamespaceProperty);
}
}
foreach (var name in namelist)
{
CleanLab(client, name);
}
return("Deleted Labs");
}
public async Task CreateKamusSecret_LabelsCopiedAndAnnotationsNot()
{
Cleanup();
await DeployController();
var kubernetes = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
var result = await kubernetes.ListNamespacedSecretWithHttpMessagesAsync(
"default",
watch : true
);
var subject = new ReplaySubject <(WatchEventType, V1Secret)>();
result.Watch <V1Secret>(
onEvent: (@type, @event) => subject.OnNext((@type, @event)),
onError: e => subject.OnError(e),
onClosed: () => subject.OnCompleted());
RunKubectlCommand("apply -f tls-KamusSecretV1Alpha2.yaml");
mTestOutputHelper.WriteLine("Waiting for secret creation");
var(_, v1Secret) = await subject
.Where(t => t.Item1 == WatchEventType.Added && t.Item2.Metadata.Name == "my-tls-secret").Timeout(TimeSpan.FromSeconds(30)).FirstAsync();
Assert.Equal(1, v1Secret.Metadata.Labels.Count);
Assert.True(v1Secret.Metadata.Labels.Keys.Contains("key"));
Assert.Equal("value", v1Secret.Metadata.Labels.First(x => x.Key == "key").Value);
Assert.Null(v1Secret.Metadata.Annotations);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(Configuration)
.CreateLogger();
services.AddSingleton(Configuration);
services.AddControllers().AddNewtonsoftJson();
services.AddKeyManagement(Configuration, Log.Logger);
services.AddSingleton <IKubernetes>(s =>
{
var k = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
k.HttpClient.Timeout = TimeSpan.FromMilliseconds(int.MaxValue);
return(k);
}
);
services.AddHostedService(serviceProvider =>
{
var setOwnerReference = Configuration.GetValue <bool>("Controller:SetOwnerReference", true);
var reconciliationIntervalInSeconds = Configuration.GetValue <double>("Controller:ReconciliationIntervalInSeconds", 60);
var kubernetes = serviceProvider.GetService <IKubernetes>();
var kms = serviceProvider.GetService <IKeyManagement>();
var metrics = serviceProvider.GetService <IMetrics>();
return(new V1Alpha2Controller(kubernetes, kms, setOwnerReference, reconciliationIntervalInSeconds, metrics));
});
services.AddHealthChecks()
.AddCheck <KubernetesPermissionsHelthCheck>("permissions check");
}
public async Task UpdateKamusSecret_SecretUpdated(string fileName)
{
Cleanup();
await DeployController();
RunKubectlCommand("apply -f tls-Secret.yaml");
RunKubectlCommand("apply -f tls-KamusSecret.yaml");
var kubernetes = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
var result = await kubernetes.ListNamespacedSecretWithHttpMessagesAsync(
"default",
watch : true
);
var subject = new ReplaySubject <(WatchEventType, V1Secret)>();
result.Watch <V1Secret>(
onEvent: (@type, @event) => subject.OnNext((@type, @event)),
onError: e => subject.OnError(e),
onClosed: () => subject.OnCompleted());
RunKubectlCommand($"apply -f {fileName}");
mTestOutputHelper.WriteLine("Waiting for secret update");
var(_, v1Secret) = await subject
.Where(t => t.Item1 == WatchEventType.Modified && t.Item2.Metadata.Name == "my-tls-secret")
.Timeout(TimeSpan.FromSeconds(30)).FirstAsync();
Assert.Equal("TlsSecret", v1Secret.Type);
Assert.True(v1Secret.Data.ContainsKey("key"));
Assert.Equal("modified_hello", Encoding.UTF8.GetString(v1Secret.Data["key"]));
}
public static IClientBuilder UseKubeGatewayListProvider(this IClientBuilder builder,
Action <KubeGatewayOptions> configureOptions = null)
{
return(builder.ConfigureServices((ctx, services) =>
{
services.AddOptions <KubeGatewayOptions>();
services.Configure <KubeGatewayOptions>(configureOptions);
KubernetesClientConfiguration config = default;
if (KubernetesClientConfiguration.IsInCluster())
{
config = KubernetesClientConfiguration.InClusterConfig();
}
else
{
config = KubernetesClientConfiguration.BuildDefaultConfig();
}
services.AddSingleton <IGatewayListProvider>(sp => new KubeGatewayListProvider(
sp.GetRequiredService <ILoggerFactory>(),
sp.GetRequiredService <IOptions <ClusterOptions> >(),
sp.GetRequiredService <IOptions <GatewayOptions> >(),
sp.GetRequiredService <IOptions <KubeGatewayOptions> >(),
new k8s.Kubernetes(config)
));
}));
}
private async Task DeployController()
{
Console.WriteLine("Deploying CRD");
RunKubectlCommand("apply -f deployment.yaml");
//The `--validate=false` is required because of `preserveUnknownFields` which is not support on k8s bellow 1.15
RunKubectlCommand("apply -f crd.yaml --validate=false");
var kubernetes = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
Console.WriteLine("Waiting for deployment to complete");
try
{
var status = await Observable
.Interval(TimeSpan.FromMilliseconds(5000))
.SelectMany(_ => Observable.FromAsync(() => kubernetes.ReadNamespacedDeploymentAsync("kamus-crd-controller", "default")))
.Select(d => d.Status)
.Where(d => !d.UnavailableReplicas.HasValue)
.Timeout(TimeSpan.FromMinutes(2))
.FirstAsync();
}
catch (TimeoutException)
{
RunKubectlCommand("get pods", true);
throw;
}
Console.WriteLine("Controller deployed successfully");
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton(Configuration);
services.AddControllers().AddNewtonsoftJson();
services.AddKeyManagement(Configuration, Log.Logger);
services.AddSingleton <IKubernetes>(s =>
{
var k = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
k.HttpClient.Timeout = TimeSpan.FromMinutes(60);
return(k);
}
);
services.AddHostedService(serviceProvider =>
{
var setOwnerReference = Configuration.GetValue <bool>("Controller:SetOwnerReference", true);
var kubernetes = serviceProvider.GetService <IKubernetes>();
var kms = serviceProvider.GetService <IKeyManagement>();
return(new V1Alpha2Controller(kubernetes, kms, setOwnerReference));
});
services.AddHealthChecks()
.AddCheck <KubernetesPermissionsHelthCheck>("permisssions check");
}
public static async Task BackgroundAsync(string serverAppUrl)
{
Console.WriteLine($"Background work starting. Sending requests to {serverAppUrl}");
while (true)
{
try
{
using var kubernetes = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
using var httpClient = new HttpClient(
new CredentialsHandler(kubernetes.Credentials)
{
InnerHandler = new HttpClientHandler()
});
var result = await httpClient.GetStringAsync(serverAppUrl);
Console.WriteLine(result);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
await Task.Delay(TimeSpan.FromSeconds(3));
}
}
public async Task DeleteKamusSecret_SecretDeleted(string fileName)
{
Cleanup();
await DeployController();
RunKubectlCommand($"apply -f {fileName}");
var kubernetes = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
var result = await kubernetes.ListNamespacedSecretWithHttpMessagesAsync(
"default",
watch : true
);
var subject = new ReplaySubject <(WatchEventType, V1Secret)>();
result.Watch <V1Secret>(
onEvent: (@type, @event) => subject.OnNext((@type, @event)),
onError: e => subject.OnError(e),
onClosed: () => subject.OnCompleted());
RunKubectlCommand($"delete -f {fileName}");
mTestOutputHelper.WriteLine("Waiting for secret deletion");
var(_, v1Secret) = await subject.Where(t => t.Item1 == WatchEventType.Deleted && t.Item2.Metadata.Name == "my-tls-secret")
.Timeout(TimeSpan.FromSeconds(30)).FirstAsync();
}
private static void Main(string[] args)
{
var config = KubernetesClientConfiguration.BuildDefaultConfig();
IKubernetes client = new Kubernetes(config);
Console.WriteLine("Starting Request!");
var podHealth = client.ListNamespacedPod("default");
foreach (var pod in podHealth.Items)
{
if (pod.Status.Message != null)
{
Console.WriteLine("************************");
Console.WriteLine("Pod name: " + pod.Metadata.Name);
Console.WriteLine("Pod status message: " + pod.Status.Message);
Console.WriteLine("Pod container statuses: " + pod.Status.ContainerStatuses);
Console.WriteLine("Pod status conditions: " + pod.Status.Conditions);
Console.WriteLine("Pod status reason: " + pod.Status.Reason);
Console.WriteLine("Pod status phase: " + pod.Status.Phase);
Console.WriteLine("Pod start time: " + pod.Status.StartTime);
Console.WriteLine("************************");
}
}
if (podHealth.Items.Count == 0)
{
Console.WriteLine("Empty!");
Console.WriteLine("Check your namespace!");
}
}
public IActionResult Index()
{
string userName = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var k8SClientConfig = KubernetesClientConfiguration.BuildDefaultConfig();
var client = new Kubernetes(k8SClientConfig);
var TemplateId = HttpContext.Session.GetInt32("TemplateId");
var labName = _context.Template.Find(TemplateId).Lab;
var list = client.ListNamespacedDeployment(userName, null, null, null, "lab = " + labName);
var slist = client.ListNamespacedService(userName, null, null, null, "lab = " + labName);
var ilist = client.ListNamespacedIngress1(userName, null, null, null, "lab = " + labName);
var nlist = client.ListNamespacedNetworkPolicy(userName, null, null, null, "lab = " + labName);
foreach (var item in list.Items)
{
client.DeleteNamespacedDeployment(item.Metadata.Name, userName);
}
foreach (var item in slist.Items)
{
client.DeleteNamespacedService(item.Metadata.Name, userName);
}
foreach (var item in ilist.Items)
{
client.DeleteNamespacedIngress1(item.Metadata.Name, userName);
}
foreach (var item in nlist.Items)
{
client.DeleteNamespacedNetworkPolicy(item.Metadata.Name, userName);
}
return(View());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().AddNewtonsoftJson();
services.AddSwaggerGen(swagger => {
swagger.SwaggerDoc("v1", new OpenApiInfo {
Title = "Kamus Encryptor API", Version = "v1"
});
});
services.AddSingleton <IKubernetes>(s => {
var config = string.IsNullOrEmpty(Configuration["Kubernetes:ProxyUrl"])
? KubernetesClientConfiguration.BuildDefaultConfig()
: new KubernetesClientConfiguration {
Host = Configuration["Kubernetes:ProxyUrl"]
};
return(new Kubernetes(config));
});
services.AddKeyManagement(Configuration, Log.Logger);
services.AddAuthentication().AddScheme <KubernetesAuthenticationOptions, KubernetesAuthenticationHandler>("kubernetes", null);
services.AddAuthorization(options => {
options.AddPolicy("KubernetesPolicy", policyBuilder => policyBuilder.RequireAssertion(
context => context.Resource as string == context.User.Claims.FirstOrDefault(claim => claim.Type == "sub").Value)
);
});
services.AddSingleton <IConfiguration>(Configuration);
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
}
public static async Task AnotherBackgroundAsync(string serverAppUrl)
{
Console.WriteLine($"Background work starting. Sending requests to {serverAppUrl}");
while (true)
{
try
{
using var kubernetes = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
var httpRequest = new HttpRequestMessage(HttpMethod.Get, serverAppUrl);
await kubernetes.Credentials.ProcessHttpRequestAsync(httpRequest, default);
using var httpClient = new HttpClient();
var result = await httpClient.SendAsync(httpRequest);
Console.WriteLine(await result.Content.ReadAsStringAsync());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
await Task.Delay(TimeSpan.FromSeconds(3));
}
}
public static async Task Main(string[] args)
{
// Learn more about generic hosts at https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/generic-host
using (var host = new HostBuilder()
.ConfigureLogging((logging) =>
{
logging.AddConsole();
})
.ConfigureServices((hostBuilderContext, services) =>
{
// Ideally this config would be read from the .net core config constructs,
// but that has not been implemented in the KubernetesClient library at
// the time this sample was created.
var config = KubernetesClientConfiguration.BuildDefaultConfig();
services.AddSingleton(config);
// Setup the http client
services.AddHttpClient("K8s")
.AddTypedClient <IKubernetes>((httpClient, serviceProvider) =>
{
return(new Kubernetes(
serviceProvider.GetRequiredService <KubernetesClientConfiguration>(),
httpClient));
});
// Add the class that uses the client
services.AddHostedService <PodListHostedService>();
})
.Build())
{
await host.StartAsync().ConfigureAwait(false);
await host.StopAsync().ConfigureAwait(false);
}
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseSerilog(Log.Logger)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
})
.ConfigureServices(services =>
{
KubernetesClientConfiguration kubeConfig = null;
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "production")
{
kubeConfig = KubernetesClientConfiguration.InClusterConfig();
}
else
{
kubeConfig = KubernetesClientConfiguration.BuildDefaultConfig();
}
services.AddSingleton(kubeConfig);
// Setup the http client
services.AddHttpClient("K8s")
.AddTypedClient <IKubernetes>((httpClient, serviceProvider) => new Kubernetes(
serviceProvider.GetRequiredService <KubernetesClientConfiguration>(),
httpClient))
.ConfigurePrimaryHttpMessageHandler(kubeConfig.CreateDefaultHttpClientHandler);
// Controller Watching service
services.AddHostedService <AcmeHttpChallengeService>();
});
private void ConfigureRequiredServices() =>
Builder.ConfigureServices(
services =>
{
services.AddSingleton(OperatorSettings);
services.AddTransient(
_ => new JsonSerializerSettings
{
ContractResolver = new NamingConvention(),
Converters = new List <JsonConverter>
{
new StringEnumConverter {
NamingStrategy = new CamelCaseNamingStrategy()
}
},
});
services.AddTransient(
_ => new SerializerBuilder()
.ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull)
.WithNamingConvention(new NamingConvention())
.Build());
services.AddTransient <EntitySerializer>();
services.AddTransient <IKubernetesClient, KubernetesClient>();
services.AddSingleton <IKubernetes>(
_ =>
{
var config = KubernetesClientConfiguration.BuildDefaultConfig();
return(new Kubernetes(config, new ClientUrlFixer())
{
SerializationSettings =
{
ContractResolver = new NamingConvention(),
Converters = new List <JsonConverter>
{
new StringEnumConverter {
NamingStrategy = new CamelCaseNamingStrategy()
}
}
},
DeserializationSettings =
{
ContractResolver = new NamingConvention(),
Converters = new List <JsonConverter>
{
new StringEnumConverter {
NamingStrategy = new CamelCaseNamingStrategy()
}
}
}
});
});
services.AddTransient(typeof(IResourceCache <>), typeof(ResourceCache <>));
services.AddTransient(typeof(IResourceWatcher <>), typeof(ResourceWatcher <>));
services.AddTransient(typeof(IResourceEventQueue <>), typeof(ResourceEventQueue <>));
});
public async static Task DeleteNamesapcePodsAsync(string podName, string namespaceName)
{
var client = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
await client.DeleteNamespacedPodAsync(podName, namespaceName, new V1DeleteOptions()
{
GracePeriodSeconds = 0
});
}
public KubernetesRepository()
{
// _client = new Kubernetes(
// KubernetesClientConfiguration.InClusterConfig()
// );
_client = new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
}
private KubernetesClientConfiguration GetConfig()
{
if (UseLocalConfig)
{
// Use this when debugging locally
return(KubernetesClientConfiguration.BuildConfigFromConfigFile(@"C:\Users\corey.caldwell\.kube\config", "sk-sandbox-westus2-aks-admin"));
}
return(KubernetesClientConfiguration.BuildDefaultConfig());
}
private KubernetesClient CreateKubernetesClient()
{
return(new KubernetesClient(
new KubernetesProtocol(
KubernetesClientConfiguration.BuildDefaultConfig(),
this.loggerFactory.CreateLogger <KubernetesProtocol>(),
this.loggerFactory),
KubernetesOptions.Default,
this.loggerFactory.CreateLogger <KubernetesClient>(),
this.loggerFactory));
}
public KubernetesClientConfiguration Get()
{
var location = this.options.Value.Location ?? string.Empty;
return(location switch
{
"default" or "" => KubernetesClientConfiguration.BuildDefaultConfig(),
"kubeconfig" => KubernetesClientConfiguration.BuildConfigFromConfigFile(Environment.GetEnvironmentVariable("KUBECONFIG")),
"cluster" => KubernetesClientConfiguration.InClusterConfig(),
_ => throw new ArgumentOutOfRangeException("Kubeconfig.Location"),
});
public void ExistingClientIsNotReplaced()
{
using var client = new k8s.Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
var services = new ServiceCollection();
services.AddSingleton <IKubernetes>(client);
services.AddKubernetesCore();
var serviceProvider = services.BuildServiceProvider();
Assert.Same(client, serviceProvider.GetService <IKubernetes>());
}
