static IServiceCollection AddKubernetesDiscoveryService(this IServiceCollection services, KubernetesDiscoverySettings kubernetesDiscoverySettings) { KubernetesClientConfiguration kubernetesConfig; if (!string.IsNullOrEmpty(kubernetesDiscoverySettings.ClusterHost) && !string.IsNullOrEmpty(kubernetesDiscoverySettings.Token)) { kubernetesConfig = new KubernetesClientConfiguration { Host = kubernetesDiscoverySettings.ClusterHost, AccessToken = kubernetesDiscoverySettings.Token, // Some cloud services like Azure AKS use self-signed certificates not valid for httpclient. // With this method we allow invalid certificates SkipTlsVerify = true }; } else if (KubernetesClientConfiguration.IsInCluster()) { kubernetesConfig = KubernetesClientConfiguration.InClusterConfig(); } else { kubernetesConfig = KubernetesClientConfiguration.BuildConfigFromConfigFile(); } services.AddSingleton(kubernetesDiscoverySettings) .AddHostedService <KubernetesDiscoveryHostedService>() .AddSingleton <IKubernetes>(new Kubernetes(kubernetesConfig)) .AddHttpClient(Keys.K8S_CLUSTER_SERVICE_HTTP_CLIENT_NAME); return(services); }
public void ConfigureServices(IServiceCollection services) { KubernetesClientConfiguration config; if (KubernetesClientConfiguration.IsInCluster()) { config = KubernetesClientConfiguration.InClusterConfig(); services.AddSingleton <ILeaderSelector, KubernetesLeaderSelector>(); } else { config = new KubernetesClientConfiguration { Host = "http://localhost:8001" }; services.AddSingleton <ILeaderSelector, DummyLeaderSelector>(); } services.AddHttpClient("K8s") .AddTypedClient <IKubernetes>((httpClient, serviceProvider) => new Kubernetes(config, httpClient)) .ConfigurePrimaryHttpMessageHandler(config.CreateDefaultHttpClientHandler) .AddHttpMessageHandler(KubernetesClientConfiguration.CreateWatchHandler); services.AddSingleton <ResourceSet <Foo> >(); services.AddHostedService <CrdControllerService>(); }
public void ConfigureServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); services.AddSingleton(s => { var logger = s.GetRequiredService <ILogger <Startup> >(); var inCluster = KubernetesClientConfiguration.IsInCluster(); logger.LogDebug("Building client configuration. Client is in cluster: '{inCluster}'", inCluster); return(inCluster ? KubernetesClientConfiguration.InClusterConfig() : KubernetesClientConfiguration.BuildConfigFromConfigFile()); }); services.AddSingleton <IKubernetes>(s => { var logger = s.GetRequiredService <ILogger <Startup> >(); logger.LogDebug("Initializing Kubernetes client"); return(new k8s.Kubernetes(s.GetRequiredService <KubernetesClientConfiguration>()) { HttpClient = { Timeout = TimeSpan.FromMinutes(60) } }); }); services.AddTransient <SecretsMonitor>(); services.AddTransient <ConfigMapMonitor>(); services.AddTransient <CustomResourceDefinitionMonitor>(); services.AddTransient <CertManagerCertificatesMonitor>(); services.AddHostedService <SecretsMirror>(); services.AddHostedService <ConfigMapMirror>(); services.AddHostedService <CertManagerMirror>(); }
public void ConfigureServices(IServiceCollection services) { KubernetesClientConfiguration config; if (KubernetesClientConfiguration.IsInCluster()) { config = KubernetesClientConfiguration.InClusterConfig(); services.AddSingleton <ILeaderSelector, KubernetesLeaderSelector>(); } else { config = new KubernetesClientConfiguration { Host = "http://localhost:8001" }; services.AddSingleton <ILeaderSelector, DummyLeaderSelector>(); } services.AddHttpClient("K8s") .AddTypedClient <IKubernetes>((httpClient, serviceProvider) => new Kubernetes(config, httpClient)) .ConfigurePrimaryHttpMessageHandler(config.CreateDefaultHttpClientHandler) .AddHttpMessageHandler(KubernetesClientConfiguration.CreateWatchHandler); services.AddSingleton <ConcurrentDictionary <string, AzureDnsCredentialSpec> >(); services.AddSingleton <IDnsClientFactory, AzureDnsClientFactory>(); services.AddHostedService <AzureDnsCredentialsController>(); services.AddHostedService <DnsRecordsetController>(); }
static async Task Main(string[] args) { var config = new ConfigurationBuilder() .AddJsonFile("config/appsettings.json", optional: true) .Build(); var kubeConfig = KubernetesClientConfiguration.IsInCluster() ? KubernetesClientConfiguration.InClusterConfig() : new KubernetesClientConfiguration { Host = "http://localhost:8001" }; var kubernetes = new Kubernetes(kubeConfig); var serviceProvider = new ServiceCollection() .AddSingleton(config) .AddSingleton(kubernetes) .AddTransient <IInstaller, WebPingerInstaller>() .AddTransient <IInstaller, WebPingerArchiveInstaller>() .BuildServiceProvider(); var installers = serviceProvider.GetServices <IInstaller>(); foreach (var installer in installers) { await installer.InstallAsync(); } Console.WriteLine("* Done."); }
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .ConfigureServices((hostContext, services) => { services.AddHostedService <HealthChecksOperator>() .AddSingleton <IKubernetes>(sp => { var config = KubernetesClientConfiguration.IsInCluster() ? KubernetesClientConfiguration.InClusterConfig() : KubernetesClientConfiguration.BuildConfigFromConfigFile(); return(new Kubernetes(config)); }) .AddTransient <IHealthChecksController, HealthChecksController>() .AddSingleton <OperatorDiagnostics>() .AddSingleton <DeploymentHandler>() .AddSingleton <ServiceHandler>() .AddSingleton <SecretHandler>() .AddSingleton <ConfigMaphandler>() .AddSingleton <HealthCheckServiceWatcher>(); }).ConfigureLogging((context, builder) => { var logger = new LoggerConfiguration() .MinimumLevel.Information() .MinimumLevel.Override("Microsoft", LogEventLevel.Warning) .Enrich.WithProperty("Application", nameof(K8sOperator)) .Enrich.FromLogContext() .WriteTo.ColoredConsole(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception:lj}") .CreateLogger(); builder.ClearProviders(); builder.AddSerilog(logger, dispose: true); });
private IKubernetes InitializeKubernetesClient() { KubernetesClientConfiguration kubernetesConfig; if (!string.IsNullOrEmpty(_discoveryOptions.ClusterHost) && !string.IsNullOrEmpty(_discoveryOptions.Token)) { kubernetesConfig = new KubernetesClientConfiguration { Host = _discoveryOptions.ClusterHost, AccessToken = _discoveryOptions.Token, // Some cloud services like Azure AKS use self-signed certificates not valid for httpclient. // With this method we allow invalid certificates SkipTlsVerify = true }; } else if (KubernetesClientConfiguration.IsInCluster()) { kubernetesConfig = KubernetesClientConfiguration.InClusterConfig(); } else { kubernetesConfig = KubernetesClientConfiguration.BuildConfigFromConfigFile(); } return(new Kubernetes(kubernetesConfig)); }
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) )); })); }
static async Task Main(string[] args) { KubernetesClientConfiguration config; if (KubernetesClientConfiguration.IsInCluster()) { config = KubernetesClientConfiguration.InClusterConfig(); } else { config = new KubernetesClientConfiguration { Host = "http://localhost:8001" }; } _Client = new Kubernetes(config); var result = await _Client.ListNamespacedCustomObjectWithHttpMessagesAsync( group : User.Definition.Group, version : User.Definition.Version, plural : User.Definition.Plural, namespaceParameter : "default", watch : true); using (result.Watch <User, object>((type, item) => Handle(type, item))) { Console.WriteLine("* Watching for custom object events"); _ResetEvent.WaitOne(); } }
private static IKubernetes GetKubernetesClient() { var config = KubernetesClientConfiguration.IsInCluster() ? KubernetesClientConfiguration.InClusterConfig() : KubernetesClientConfiguration.BuildConfigFromConfigFile(); return(new Kubernetes(config)); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.MapGet("/", async context => { await context.Response.WriteAsync(context.Request.Host.ToString()); await context.Response.WriteAsync(Environment.NewLine); await context.Response.WriteAsync("Hello from backend!!!"); }); endpoints.MapGet("/env", async context => { context.Response.ContentType = "application/json"; var configuration = context.RequestServices.GetRequiredService <IConfiguration>() as IConfigurationRoot; var vars = Environment.GetEnvironmentVariables() .Cast <DictionaryEntry>() .OrderBy(e => (string)e.Key) .ToDictionary(e => (string)e.Key, e => (string)e.Value); var data = new { version = Environment.Version.ToString(), env = vars, configuration = configuration.AsEnumerable().ToDictionary(c => c.Key, c => c.Value), configurtionDebug = configuration.GetDebugView(), }; await JsonSerializer.SerializeAsync(context.Response.Body, data); }); endpoints.MapGet("/replicas", async context => { context.Response.ContentType = "application/json"; if (!KubernetesClientConfiguration.IsInCluster()) { await JsonSerializer.SerializeAsync(context.Response.Body, new { message = "Not running in k8s" }); return; } var config = KubernetesClientConfiguration.InClusterConfig(); var klient = new Kubernetes(config); var endpointsList = await klient.ListNamespacedEndpointsAsync("default"); await JsonSerializer.SerializeAsync(context.Response.Body, endpointsList.Items); }); }); }
private static void Main(string[] args) { var appConfig = new ConfigurationBuilder() .AddEnvironmentVariables() .Build(); var loadBalancerTarget = appConfig["LOAD_BALANCER_TARGET"]; var channel = new Channel(loadBalancerTarget, ChannelCredentials.Insecure); _client = new ConfigRemoteClient(new ConfigRemote.ConfigRemoteClient(channel)); var config = KubernetesClientConfiguration.IsInCluster() ? KubernetesClientConfiguration.InClusterConfig() : KubernetesClientConfiguration.BuildDefaultConfig(); _k8sClient = new Kubernetes(config); Console.WriteLine($"Current context {config.CurrentContext}"); Console.WriteLine($"Connecting to {_k8sClient.BaseUri}"); var listNodeAsync = _k8sClient.ListNodeAsync(); var nodesInfo = new NodesInfo(listNodeAsync.Result); var ingressLister = _k8sClient.ListIngressForAllNamespacesWithHttpMessagesAsync(watch: true); using (ingressLister.Watch <Extensionsv1beta1Ingress, Extensionsv1beta1IngressList>((type, item) => { switch (type) { case WatchEventType.Added: HandleIngressAdded(item, nodesInfo); break; default: Console.WriteLine($"Unhandled event for ingress {item.Metadata.Name}"); break; } })) { Console.WriteLine("Watching for ingress changes..."); Console.ReadLine(); } }
public void IsInCluster() { Assert.False(KubernetesClientConfiguration.IsInCluster()); var tokenPath = Path.Combine(KubernetesClientConfiguration.ServiceAccountPath, KubernetesClientConfiguration.ServiceAccountTokenKeyFileName); var certPath = Path.Combine(KubernetesClientConfiguration.ServiceAccountPath, KubernetesClientConfiguration.ServiceAccountRootCAKeyFileName); var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> { { tokenPath, new MockFileData("foo") }, { certPath, new MockFileData("bar") }, }); using (new FileUtils.InjectedFileSystem(fileSystem)) { Assert.True(KubernetesClientConfiguration.IsInCluster()); } }
public Controller(T crd, IOperationHandler <T> handler, string k8sNamespace = "") { KubernetesClientConfiguration config; if (KubernetesClientConfiguration.IsInCluster()) { config = KubernetesClientConfiguration.InClusterConfig(); } else { config = KubernetesClientConfiguration.BuildConfigFromConfigFile(); } Kubernetes = new Kubernetes(config); m_k8sNamespace = k8sNamespace; m_crd = crd; m_handler = handler; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllersWithViews(); services.AddTransient <IKubernetes>(ser => { KubernetesClientConfiguration config; if (!KubernetesClientConfiguration.IsInCluster()) { config = KubernetesClientConfiguration.BuildConfigFromConfigFile(); } else { config = KubernetesClientConfiguration.InClusterConfig(); } return(new Kubernetes(config)); }); }
public void IsInCluster() { Assert.False(KubernetesClientConfiguration.IsInCluster()); Environment.SetEnvironmentVariable("KUBERNETES_SERVICE_HOST", "kubernetes"); Environment.SetEnvironmentVariable("KUBERNETES_SERVICE_PORT", "443"); var tokenPath = Path.Combine(KubernetesClientConfiguration.ServiceAccountPath, KubernetesClientConfiguration.ServiceAccountTokenKeyFileName); var certPath = Path.Combine(KubernetesClientConfiguration.ServiceAccountPath, KubernetesClientConfiguration.ServiceAccountRootCAKeyFileName); var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> { { tokenPath, new MockFileData("foo") }, { certPath, new MockFileData("bar") }, }); using (new FileUtils.InjectedFileSystem(fileSystem)) { Assert.True(KubernetesClientConfiguration.IsInCluster()); } }
public static ISiloBuilder UseKubeMembership(this ISiloBuilder builder) { return(builder.ConfigureServices((ctx, services) => { KubernetesClientConfiguration config = default; if (KubernetesClientConfiguration.IsInCluster()) { config = KubernetesClientConfiguration.InClusterConfig(); } else { config = KubernetesClientConfiguration.BuildDefaultConfig(); } services.AddSingleton <IMembershipTable>(sp => new KubeMembershipTable( sp.GetRequiredService <ILoggerFactory>(), sp.GetRequiredService <IOptions <ClusterOptions> >(), new k8s.Kubernetes(config) )); })); }
protected override void Load(ContainerBuilder builder) { builder.RegisterGeneric(typeof(ManagedWatcher <,>)); builder.RegisterGeneric(typeof(ManagedWatcher <, ,>)); builder.Register(s => { var logger = s.Resolve <ILogger <CoreModule> >(); var inCluster = KubernetesClientConfiguration.IsInCluster(); logger.LogDebug("Building client configuration. Client is in cluster: '{inCluster}'", inCluster); return(inCluster ? KubernetesClientConfiguration.InClusterConfig() : KubernetesClientConfiguration.BuildConfigFromConfigFile()); }).As <KubernetesClientConfiguration>().SingleInstance(); builder.Register(s => new k8s.Kubernetes(s.Resolve <KubernetesClientConfiguration>()) { HttpClient = { Timeout = TimeSpan.FromMinutes(60) } }).As <k8s.Kubernetes>().As <IKubernetes>(); }
/// <summary> /// Uses a Kubernetes-base <see cref="IWorkflowRuntime"/> /// </summary> /// <param name="app">The <see cref="ISynapseApplicationBuilder"/> to configure</param> /// <returns>The configured <see cref="ISynapseApplicationBuilder"/></returns> public static ISynapseApplicationBuilder UseKubernetesRuntimeHost(this ISynapseApplicationBuilder app) { var runtimeHostOptions = new KubernetesRuntimeOptions(); app.Configuration.Bind("kubernetes", runtimeHostOptions); app.Services.AddSingleton <KubernetesRuntimeHost>(); app.Services.AddSingleton <IWorkflowRuntime>(provider => provider.GetRequiredService <KubernetesRuntimeHost>()); app.Services.AddSingleton <IHostedService>(provider => provider.GetRequiredService <KubernetesRuntimeHost>()); var config = null as KubernetesClientConfiguration; if (KubernetesClientConfiguration.IsInCluster()) { config = KubernetesClientConfiguration.InClusterConfig(); } else { config = KubernetesClientConfiguration.BuildDefaultConfig(); } app.Services.AddKubernetesClient(config); app.Services.TryAddSingleton(Options.Create(runtimeHostOptions)); return(app); }
static async Task Main(string[] args) { var config = new ConfigurationBuilder() .AddJsonFile("config/appsettings.json", optional: true) .Build(); var kubeConfig = KubernetesClientConfiguration.IsInCluster() ? KubernetesClientConfiguration.InClusterConfig() : new KubernetesClientConfiguration { Host = "http://localhost:8001" }; var kubernetes = new Kubernetes(kubeConfig); _ServiceProvider = new ServiceCollection() .AddSingleton(config) .AddSingleton(kubernetes) .AddTransient <WebPingerArchiveAddedHandler>() .AddTransient <WebPingerArchiveDeletedHandler>() .BuildServiceProvider(); // TODO - this hangs and then fails if there are no objects var result = await kubernetes.ListNamespacedCustomObjectWithHttpMessagesAsync( group : WebPingerArchive.Definition.Group, version : WebPingerArchive.Definition.Version, plural : WebPingerArchive.Definition.Plural, namespaceParameter : "default", watch : true); using (result.Watch <WebPingerArchive, object>(async(type, item) => await Handle(type, item))) { Console.WriteLine("* Watching for WebPingerArchive events"); var ctrlc = new ManualResetEventSlim(false); Console.CancelKeyPress += (sender, eventArgs) => ctrlc.Set(); ctrlc.Wait(); } }
public static IConfigurationBuilder AddJsonKubeConfigMap(this IConfigurationBuilder builder, string name, string @namespace, string key, bool onlyInCluster = true) { var isInCluster = KubernetesClientConfiguration.IsInCluster(); if (onlyInCluster && !isInCluster) { return(builder); } var config = isInCluster ? KubernetesClientConfiguration.InClusterConfig() : KubernetesClientConfiguration.BuildDefaultConfig(); IKubernetes client = new Kubernetes(config); var json = client.ReadNamespacedConfigMap(name, @namespace)?.Data[key]; if (!string.IsNullOrEmpty(json)) { builder.AddJsonStream(new MemoryStream(Encoding.UTF8.GetBytes(json))); } return(builder); }
private static IServiceProvider ConfigureServices() { var configuration = BuildConfiguration(); var services = new ServiceCollection(); services.AddSingleton(configuration); services.AddHttpClient("k8s"); services.AddLogging(configure => configure.AddConsole()) .Configure <LoggerFilterOptions>(configure => configure.MinLevel = LogLevel.Debug); services.AddMetrics(builder => { new MetricsReporterBuilder().Chain(builder.Report, configuration.GetSection("Metrics:Reporting")); }); services.AddScoped <IKubernetes, Kubernetes>(provider => { var factory = provider.GetRequiredService <ILoggerFactory>(); var logger = factory.CreateLogger <HttpClient>(); var loggingHandler = new LoggingHttpMessageHandler(logger); var config = KubernetesClientConfiguration.IsInCluster() ? KubernetesClientConfiguration.InClusterConfig() : KubernetesClientConfiguration.BuildDefaultConfig(); return(new Kubernetes(config, loggingHandler)); }); services.AddScoped <IKubernetesService, KubernetesService>(); services.AddScoped <ISqlManagementService, SqlManagementService>(); services.AddScoped <SecretSourceRehydrator>(); services.AddScoped <DatabaseServerRehydrator>(); services.AddOperator <DatabaseResource, DatabaseOperator>(); services.AddOperator <DatabaseServerResource, DatabaseServerOperator>(); services.AddOperator <DeploymentScriptResource, DeploymentScriptOperator>(); services.AddOperator <CredentialsResource, CredentialsOperator>(); return(services.BuildServiceProvider()); }
/// <summary> /// Handles purging of old <b>logstash</b> and <b>metricbeat</b> Elasticsearch indexes. /// </summary> /// <returns>The tracking <see cref="Task"/>.</returns> public async Task LogPurgerAsync(TimeSpan logPurgerInterval, int retentionDays) { using (var jsonClient = new JsonClient()) { jsonClient.BaseAddress = KubernetesClientConfiguration.IsInCluster() ? this.ServiceMap[NeonServices.Elasticsearch].Endpoints.Default.Uri : new Uri($"http://localhost:{this.ServiceMap[NeonServices.Elasticsearch].Endpoints.Default.Port}"); var periodicTask = new AsyncPeriodicTask( logPurgerInterval, onTaskAsync: async() => { // We're going to list the indexes and look for [logstash] // and [metricbeat] indexes that encode the index date like: // // logstash-2018.06.06 // metricbeat-6.1.1-2018.06.06 // // The date is simply encodes the day covered by the index. var utcNow = DateTime.UtcNow; var deleteBeforeDate = new DateTime(utcNow.Year, utcNow.Month, utcNow.Day) - TimeSpan.FromDays(retentionDays); var indexList = await jsonClient.GetAsync <JObject>("_aliases"); foreach (var indexProperty in indexList.Properties()) { var indexName = indexProperty.Name; // We're only purging [logstash] and [metricbeat] indexes. if (!indexName.StartsWith("logstash-") && !indexName.StartsWith("metricbeat-")) { continue; } // Extract the date from the index name. var pos = indexName.LastIndexOf('-'); if (pos == -1) { Log.LogWarn(() => $"LOG-PURGER: Cannot extract date from index named [{indexName}]."); continue; } var date = indexName.Substring(pos + 1); var fields = date.Split('.'); var indexDate = default(DateTime); try { indexDate = new DateTime(int.Parse(fields[0]), int.Parse(fields[1]), int.Parse(fields[2])); } catch { Log.LogWarn(() => $"LOG-PURGER: Cannot extract date from index named [{indexName}]."); continue; } if (indexDate < deleteBeforeDate) { Log.LogInfo(() => $"LOG-PURGER: Deleting index [{indexName}]."); await jsonClient.DeleteAsync <JObject>(indexName); Log.LogInfo(() => $"LOG-PURGER: [{indexName}] was deleted."); } } Log.LogDebug("LOG-PURGER: Scan finished."); return(await Task.FromResult(false)); }, onExceptionAsync: async e => { Log.LogError("LOG-PURGER", e); return(await Task.FromResult(false)); }, onTerminateAsync: async() => { Log.LogInfo(() => "LOG-PURGER: Terminating"); await Task.CompletedTask; }); await periodicTask.Run(); } }
static async Task <int> Main(string[] args) { IOperator basicOperator = null; // Setup logging using var loggerFactory = SetupLogging(args); var logger = loggerFactory.CreateLogger <Program>(); try { logger.LogDebug($"Environment variables: {JsonConvert.SerializeObject(Environment.GetEnvironmentVariables())}"); // Setup termination handlers SetupSignalHandlers(); // Setup the Kubernetes client using var client = SetupClient(args); // Setup the operator var configuration = GetOperatorConfiguration(); basicOperator = new Operator(configuration, client, loggerFactory); basicOperator.AddControllerOfType <MyResourceController>(); // Start the operator return(await basicOperator.StartAsync()); } catch (Exception exception) { logger.LogError(exception, "Operator error"); return(1); } IKubernetes SetupClient(string[] args) { // Load the Kubernetes configuration KubernetesClientConfiguration config = null; if (KubernetesClientConfiguration.IsInCluster()) { logger.LogDebug("Loading cluster configuration"); config = KubernetesClientConfiguration.InClusterConfig(); } else { logger.LogDebug("Loading local configuration"); config = KubernetesClientConfiguration.BuildConfigFromConfigFile(); } if (logger.IsEnabled(LogLevel.Debug)) { logger.LogDebug($"Client configuration: {JsonConvert.SerializeObject(config)}"); } return(new Kubernetes(config)); } ILoggerFactory SetupLogging(string[] args) { if (!System.Enum.TryParse <LogLevel>(Environment.GetEnvironmentVariable("LOG_LEVEL"), true, out LogLevel logLevel)) { logLevel = LogLevel.Debug; } var loggerFactory = LoggerFactory.Create(builder => builder .AddConsole(options => options.Format = ConsoleLoggerFormat.Systemd) .SetMinimumLevel(logLevel) ); // Enable Kubernetes client logging if level = DEBUG ServiceClientTracing.IsEnabled = logLevel <= LogLevel.Debug; ServiceClientTracing.AddTracingInterceptor(new ConsoleTracingInterceptor()); return(loggerFactory); } void SetupSignalHandlers() { // SIGTERM: signal the operator to shut down gracefully AppDomain.CurrentDomain.ProcessExit += (s, e) => { logger.LogDebug("Received SIGTERM"); basicOperator?.Stop(); }; // SIGINT: try to shut down gracefully on the first attempt Console.CancelKeyPress += (s, e) => { bool isFirstSignal = !basicOperator.IsDisposing; logger.LogDebug($"Received SIGINT, first signal: {isFirstSignal}"); if (isFirstSignal) { e.Cancel = true; Environment.Exit(0); } }; } }
public static IKubeClient Create(KubernetesVersion kubernetesVersion) { return(KubernetesClientConfiguration.IsInCluster() ? ForInCluster(kubernetesVersion) : ForLocalProxy(kubernetesVersion)); }
/// <summary> /// Handles purging of old <b>logstash</b> and <b>metricbeat</b> Elasticsearch indexes. /// </summary> /// <returns>The tracking <see cref="Task"/>.</returns> public void KibanaSetup() { Log.LogInfo("Setting up Kibana index patterns."); using (var jsonClient = new JsonClient()) { jsonClient.BaseAddress = KubernetesClientConfiguration.IsInCluster() ? this.ServiceMap[NeonServices.Kibana].Endpoints.Default.Uri : new Uri($"http://*****:*****@timestamp"; indexPattern.attributes = attributes; await jsonClient.PostAsync($"api/saved_objects/index-pattern/logstash-*?overwrite=true", indexPattern); }).Wait(); // Now we need to save a Kibana config document so that [logstash-*] will be // the default index and the timestamp will be displayed as UTC and have a // more useful terse format. retry.InvokeAsync( async() => { dynamic setting = new ExpandoObject(); setting.value = "logstash-*"; await jsonClient.PostAsync($"api/kibana/settings/defaultIndex", setting); setting.value = "HH:mm:ss.SSS MM-DD-YYYY"; await jsonClient.PostAsync($"api/kibana/settings/dateFormat", setting); setting.value = "UTC"; await jsonClient.PostAsync($"api/kibana/settings/dateFormat:tz", setting); }).Wait(); } Log.LogInfo("Kibana index patterns configured."); }
static async Task Main(string[] args) { var cubePods = new List <string>(); if (KubernetesClientConfiguration.IsInCluster()) { var config = KubernetesClientConfiguration.BuildDefaultConfig(); var client = new Kubernetes(config); pgqList = client.ListNamespacedPod("pgq").Items .Where(i => i.Metadata.Name.StartsWith("pgq-")) .OrderBy(i => i.Metadata.Name) .Select(i => new IPEndPoint(IPAddress.Parse(i.Status.PodIP), 88)) .ToArray(); } var pgqs = Environment.GetEnvironmentVariable("H2R_PGQ_LIST"); if (!string.IsNullOrWhiteSpace(pgqs)) { pgqList = pgqs .Split(',', ';', ' ', '\r', '\n', '\t') .Where(c => !string.IsNullOrWhiteSpace(c)) .Select(c => { var parts = c.Split(':'); var host = parts[0]; Console.WriteLine(host); return(new IPEndPoint(Dns.GetHostAddresses(host)[0], int.Parse(parts[1]))); }) .ToArray(); } foreach (var ep in pgqList) { Console.WriteLine("connecting to " + ep); } var bGet = true; var bPut = true; if (args.Length > 0) { bGet = args[0].Contains("get"); bPut = args[0].Contains("put"); } if (args.Length > 1) { totalRps = int.Parse(args[1]); } Console.Write("warming up... "); var pgq = new AggPgqClient(pgqList.Select(ep => new PgqClient(ep)).ToArray()); await pgq.Warmup(); Console.WriteLine("started!"); var t = new List <Task>(); if (bGet) { t.Add(TestGet()); } if (bPut) { t.Add(TestPut()); } Console.ReadLine(); go_on = false; await Task.WhenAll(t); }