/// <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>()); }