public void LoadKubeConfigFileInfo() { var filePath = "assets/kubeconfig.yml"; var txt = File.ReadAllText(filePath); var expectedCfg = Yaml.LoadFromString <K8SConfiguration>(txt); var fileInfo = new FileInfo(filePath); var cfg = KubernetesClientConfiguration.LoadKubeConfig(fileInfo); Assert.NotNull(cfg); AssertConfigEqual(expectedCfg, cfg); }
public void LoadFromString() { var content = @"apiVersion: v1 kind: Pod metadata: name: foo "; var obj = Yaml.LoadFromString <V1Pod>(content); Assert.Equal("foo", obj.Metadata.Name); }
public void LoadFromStringWithAdditionalProperties() { var content = @"apiVersion: v1 kind: Pod metadata: name: foo youDontKnow: Me "; var obj = Yaml.LoadFromString <V1Pod>(content); Assert.Equal("foo", obj.Metadata.Name); }
/// <summary> /// Constructor of IIoTK8SClient. /// </summary> /// <param name="kubeConfigContent"></param> public IIoTK8SClient(string kubeConfigContent) { if (string.IsNullOrEmpty(kubeConfigContent)) { throw new ArgumentNullException(nameof(kubeConfigContent)); } _k8sConfiguration = Yaml.LoadFromString <K8SConfiguration>(kubeConfigContent); _k8sClientConfiguration = KubernetesClientConfiguration .BuildConfigFromConfigObject(_k8sConfiguration); _k8sClient = new Kubernetes(_k8sClientConfiguration); }
public static V1Deployment GetSpec(string name, string appName, string image, string appDir, string volumeName, string azShareName) { var obj = new RunTimeDeployment { Name = name, AppName = appName, Image = image, AppDir = appDir, VolumeName = volumeName, AzureFileShareName = azShareName, }; return(Yaml.LoadFromString <V1Deployment>(obj.TransformText())); }
public void LoadIntOrString() { var content = @"apiVersion: v1 kind: Service spec: ports: - port: 3000 targetPort: 3000 "; var obj = Yaml.LoadFromString <V1Service>(content); Assert.Equal(3000, obj.Spec.Ports[0].Port); Assert.Equal(3000, (int)obj.Spec.Ports[0].TargetPort); }
public void LoadSecret() { var kManifest = @" apiVersion: v1 kind: Secret metadata: name: test-secret data: username: bXktYXBw password: Mzk1MjgkdmRnN0pi "; var result = Yaml.LoadFromString <V1Secret>(kManifest); Assert.Equal("bXktYXBw", Encoding.UTF8.GetString(result.Data["username"])); Assert.Equal("Mzk1MjgkdmRnN0pi", Encoding.UTF8.GetString(result.Data["password"])); }
public void LoadKubeConfigStream() { var filePath = "assets/kubeconfig.yml"; var txt = File.ReadAllText(filePath); var expectedCfg = Yaml.LoadFromString <K8SConfiguration>(txt); var fileInfo = new FileInfo(filePath); K8SConfiguration cfg; using (var stream = fileInfo.OpenRead()) { cfg = KubernetesClientConfiguration.LoadKubeConfig(stream); } Assert.NotNull(cfg); AssertConfigEqual(expectedCfg, cfg); }
public async Task <V1ConfigMap> CreateV1ConfigMapAsync( string v1ConfigMapContent, string namespaceParameter = null, IDictionary <string, string> data = null, CancellationToken cancellationToken = default ) { if (string.IsNullOrEmpty(v1ConfigMapContent)) { throw new ArgumentNullException(nameof(v1ConfigMapContent)); } try { Log.Verbose("Loading k8s ConfigMap definition ..."); var v1ConfigMapDefinition = Yaml.LoadFromString <V1ConfigMap>(v1ConfigMapContent); if (null != data) { foreach (var dataKVP in data) { v1ConfigMapDefinition.Data[dataKVP.Key] = dataKVP.Value; } } if (null != namespaceParameter) { v1ConfigMapDefinition.Metadata.NamespaceProperty = namespaceParameter; } Log.Verbose($"Creating k8s ConfigMap: {v1ConfigMapDefinition.Metadata.Name} ..."); var v1ConfigMap = await _k8sClient .CreateNamespacedConfigMapAsync( v1ConfigMapDefinition, v1ConfigMapDefinition.Metadata.NamespaceProperty, cancellationToken : cancellationToken ); Log.Verbose($"Created k8s ConfigMap: {v1ConfigMap.Metadata.Name}"); return(v1ConfigMap); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s ConfigMap"); throw; } }
public async Task <V1Secret> CreateV1SecretAsync( string v1SecretContent, string namespaceParameter = null, IDictionary <string, string> data = null, CancellationToken cancellationToken = default ) { if (string.IsNullOrWhiteSpace(v1SecretContent)) { throw new ArgumentNullException(nameof(v1SecretContent)); } try { Log.Verbose("Loading k8s Secret definition ..."); var v1SecretDefinition = Yaml.LoadFromString <V1Secret>(v1SecretContent); if (null != data) { foreach (var dataKVP in data) { v1SecretDefinition.Data[dataKVP.Key] = Encoding.UTF8.GetBytes(dataKVP.Value); } } if (null != namespaceParameter) { v1SecretDefinition.Metadata.NamespaceProperty = namespaceParameter; } Log.Verbose($"Creating k8s Secret: {v1SecretDefinition.Metadata.Name} ..."); var v1Secret = await _k8sClient .CreateNamespacedSecretAsync( v1SecretDefinition, v1SecretDefinition.Metadata.NamespaceProperty, cancellationToken : cancellationToken ); Log.Verbose($"Created k8s Secret: {v1Secret.Metadata.Name}"); return(v1Secret); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s Secret"); throw; } }
public async Task <V1Secret> CreateNGINXDefaultSSLCertificateSecretAsync( string certPem, string privateKeyPem ) { try { const string tlsCrt = "tls.crt"; const string tlsKey = "tls.key"; var certPemBytes = Encoding.UTF8.GetBytes(certPem); var privateKeyPemBytes = Encoding.UTF8.GetBytes(privateKeyPem); Log.Verbose("Loading k8s Secret definition ..."); var v1SecretDefinition = Yaml .LoadFromString <k8s.Models.V1Secret>( Resources.IIoTK8SResources._20_web_app_secret ); v1SecretDefinition.Data[tlsCrt] = certPemBytes; v1SecretDefinition.Data[tlsKey] = privateKeyPemBytes; if (null != _iiotNamespace) { v1SecretDefinition.Metadata.NamespaceProperty = _iiotNamespace; } Log.Verbose($"Creating k8s Secret: {v1SecretDefinition.Metadata.Name} ..."); var v1Secret = await _k8sClient .CreateNamespacedSecretAsync( v1SecretDefinition, v1SecretDefinition.Metadata.NamespaceProperty ); Log.Verbose($"Created k8s Secret: {v1Secret.Metadata.Name}"); return(v1Secret); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s Secret"); throw; } }
public async Task <Extensionsv1beta1Ingress> CreateExtensionsv1beta1IngressAsync( string extensionsv1beta1IngressContent, string namespaceParameter = null, CancellationToken cancellationToken = default ) { if (string.IsNullOrEmpty(extensionsv1beta1IngressContent)) { throw new ArgumentNullException(nameof(extensionsv1beta1IngressContent)); } try { Log.Verbose("Loading k8s Ingress definition ..."); var extensionsv1beta1IngressDefinition = Yaml .LoadFromString <Extensionsv1beta1Ingress>( extensionsv1beta1IngressContent ); if (null != namespaceParameter) { extensionsv1beta1IngressDefinition.Metadata.NamespaceProperty = namespaceParameter; } Log.Verbose($"Creating k8s Ingress: " + $"{extensionsv1beta1IngressDefinition.Metadata.Name} ..."); var extensionsv1beta1Ingress = await _k8sClient .CreateNamespacedIngressAsync( extensionsv1beta1IngressDefinition, extensionsv1beta1IngressDefinition.Metadata.NamespaceProperty, cancellationToken : cancellationToken ); Log.Verbose($"Created k8s Ingress: {extensionsv1beta1Ingress.Metadata.Name}"); return(extensionsv1beta1Ingress); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s Ingress"); throw; } }
private async Task <V1Deployment> CreateV1DeploymentAsync( string v1DeploymentContent, string namespaceParameter = null, CancellationToken cancellationToken = default ) { if (string.IsNullOrEmpty(v1DeploymentContent)) { throw new ArgumentNullException(nameof(v1DeploymentContent)); } try { Log.Verbose("Loading k8s Deployment definition ..."); var v1DeploymentDefinition = Yaml .LoadFromString <V1Deployment>( v1DeploymentContent ); if (null != namespaceParameter) { v1DeploymentDefinition.Metadata.NamespaceProperty = namespaceParameter; } Log.Verbose($"Creating k8s Deployment: {v1DeploymentDefinition.Metadata.Name} ..."); var v1Deployment = await _k8sClient .CreateNamespacedDeploymentAsync( v1DeploymentDefinition, v1DeploymentDefinition.Metadata.NamespaceProperty, cancellationToken : cancellationToken ); Log.Verbose($"Created k8s Deployment: {v1Deployment.Metadata.Name}"); return(v1Deployment); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s Deployment"); throw; } }
/// <summary> /// Create a custom ClusterIssuer object. /// </summary> /// <param name="clusterIssuerContent"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <V1Alpha2ClusterIssuer> CreateV1Alpha2ClusterIssuerAsync( string clusterIssuerContent, CancellationToken cancellationToken = default ) { if (string.IsNullOrWhiteSpace(clusterIssuerContent)) { throw new ArgumentNullException(nameof(clusterIssuerContent)); } Log.Verbose("Loading k8s ClusterIssuer definition ..."); var clusterIssuerDefinition = Yaml .LoadFromString <V1Alpha2ClusterIssuer>( clusterIssuerContent ); Log.Verbose($"Creating k8s ClusterIssuer: {clusterIssuerDefinition.Metadata.Name} ..."); var clusterIssuerObject = await _k8sClient .CreateClusterCustomObjectAsync( clusterIssuerDefinition, V1Alpha2ClusterIssuer.KubeGroup, V1Alpha2ClusterIssuer.KubeApiVersion, V1Alpha2ClusterIssuer.KubeKindPlural, cancellationToken : cancellationToken ); // Convert returned object back to V1Alpha2ClusterIssuer. if (!(clusterIssuerObject is JObject)) { throw new Exception($"Returned object is of unexpected type: {clusterIssuerObject.GetType()}"); } // Note: Here we will loose extra fields that are not present in our V1Alpha2ClusterIssuer. var clusterIssuerJObject = (JObject)clusterIssuerObject; var clusterIssuer = clusterIssuerJObject.ToObject <V1Alpha2ClusterIssuer>(); Log.Verbose($"Created k8s ClusterIssuer: {clusterIssuerDefinition.Metadata.Name} ..."); return(clusterIssuer); }
public async Task <V1Secret> CreateIIoTEnvSecretAsync( IDictionary <string, string> env ) { try { Log.Verbose("Loading k8s Secret definition ..."); var iiotSecretDefinition = Yaml .LoadFromString <V1Secret>( Resources.IIoTK8SResources._01_industrial_iot_env_secret ); foreach (var envKVP in env) { iiotSecretDefinition.Data[envKVP.Key] = Encoding.UTF8.GetBytes(envKVP.Value); } if (null != _iiotNamespace) { iiotSecretDefinition.Metadata.NamespaceProperty = _iiotNamespace; } Log.Verbose($"Creating k8s Secret: {iiotSecretDefinition.Metadata.Name} ..."); var iiotSecret = await _k8sClient .CreateNamespacedSecretAsync( iiotSecretDefinition, iiotSecretDefinition.Metadata.NamespaceProperty ); Log.Verbose($"Created k8s Secret: {iiotSecret.Metadata.Name}"); return(iiotSecret); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s Secret"); throw; } }
public void CpuRequestAndLimitFromString() { // Taken from https://raw.githubusercontent.com/kubernetes/website/master/docs/tasks/configure-pod-container/cpu-request-limit.yaml, although // the 'namespace' property on 'metadata' was removed since it was rejected by the C# client. var content = @"apiVersion: v1 kind: Pod metadata: name: cpu-demo spec: containers: - name: cpu-demo-ctr image: vish/stress resources: limits: cpu: ""1"" requests: cpu: ""0.5"" args: - -cpus - ""2"""; var obj = Yaml.LoadFromString <V1Pod>(content); Assert.NotNull(obj?.Spec?.Containers); var container = Assert.Single(obj.Spec.Containers); Assert.NotNull(container.Resources); Assert.NotNull(container.Resources.Limits); Assert.NotNull(container.Resources.Requests); var cpuLimit = Assert.Single(container.Resources.Limits); var cpuRequest = Assert.Single(container.Resources.Requests); Assert.Equal("cpu", cpuLimit.Key); Assert.Equal("1", cpuLimit.Value.ToString()); Assert.Equal("cpu", cpuRequest.Key); Assert.Equal("500m", cpuRequest.Value.ToString()); }
public async Task <V1RoleBinding> CreateV1RoleBindingAsync( string v1RoleBindingContent, string namespaceParameter = null, CancellationToken cancellationToken = default ) { if (string.IsNullOrWhiteSpace(v1RoleBindingContent)) { throw new ArgumentNullException(nameof(v1RoleBindingContent)); } try { Log.Verbose("Loading k8s RoleBinding definition ..."); var v1RoleBindingDefinition = Yaml .LoadFromString <V1RoleBinding>(v1RoleBindingContent); if (null != namespaceParameter) { v1RoleBindingDefinition.Metadata.NamespaceProperty = namespaceParameter; } Log.Verbose($"Creating k8s RoleBinding: {v1RoleBindingDefinition.Metadata.Name} ..."); var v1RoleBinding = await _k8sClient .CreateNamespacedRoleBindingAsync( v1RoleBindingDefinition, v1RoleBindingDefinition.Metadata.NamespaceProperty, cancellationToken : cancellationToken ); Log.Verbose($"Created k8s RoleBinding: {v1RoleBindingDefinition.Metadata.Name}"); return(v1RoleBinding); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s RoleBinding"); throw; } }
public bool CheckIngress(IKubernetes client, IDeserializer deserializer, string path, string key, string value) { string curr; bool match = true; foreach (string file in Directory.EnumerateFiles(path)) { var fileContent = System.IO.File.ReadAllText(file); var ingress = Yaml.LoadFromString <Networkingv1beta1Ingress>(fileContent); if (ingress == null) { match = false; break; } // Check if NetworkPolicy has label - if no label return false if (ingress.Metadata.Labels == null) { match = false; break; } // Check if Ingress has label - if no label return false ingress.Metadata.Labels.TryGetValue(key, out curr); // If there is no match at this stage, there is a mismatch if (value != curr) { match = false; break; } } return(match); }
static bool CheckNetPol(IKubernetes client, IDeserializer deserializer, string path, string key, string value) { string curr = ""; bool match = true; foreach (string file in Directory.EnumerateFiles(path)) { var fileContent = System.IO.File.ReadAllText(file); var netPol = Yaml.LoadFromString <V1NetworkPolicy>(fileContent); if (netPol == null) { match = false; break; } if (netPol.Metadata.Labels != null) { netPol.Metadata.Labels.TryGetValue(key, out curr); } else { match = false; break; } // If there is no match at this stage, there is a error of some kind if (value != curr) { match = false; break; } } return(match); }
public void EnvVariableShouldBeStrings() { var content = @"apiVersion: v1 kind: Pod metadata: name: cpu-demo spec: containers: - env: - name: PORT value: ""3000"" image: vish/stress name: cpu-demo-ctr"; var obj = Yaml.LoadFromString <V1Pod>(content); Assert.NotNull(obj?.Spec?.Containers); var container = Assert.Single(obj.Spec.Containers); Assert.NotNull(container.Env); var objStr = Yaml.SaveToString(obj); Assert.Equal(content, objStr); }
private async Task <V1Service> CreateV1ServiceAsync( string v1ServiceContent, string namespaceParameter = null, CancellationToken cancellationToken = default ) { if (string.IsNullOrWhiteSpace(v1ServiceContent)) { throw new ArgumentNullException(nameof(v1ServiceContent)); } try { Log.Verbose("Loading k8s Service definition ..."); var v1Service = Yaml.LoadFromString <V1Service>(v1ServiceContent); if (null != namespaceParameter) { v1Service.Metadata.NamespaceProperty = namespaceParameter; } Log.Verbose($"Creating k8s Service: {v1Service.Metadata.Name} ..."); var service = await _k8sClient .CreateNamespacedServiceAsync( v1Service, v1Service.Metadata.NamespaceProperty, cancellationToken : cancellationToken ); Log.Verbose($"Created k8s Service: {service.Metadata.Name}"); return(service); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s Service"); throw; } }
public void LoadPropertyNamedReadOnlyFromString() { var content = @"apiVersion: v1 kind: Pod metadata: namespace: bar name: foo spec: containers: - image: nginx volumeMounts: - name: vm1 mountPath: /vm1 readOnly: true - name: vm2 mountPath: /vm2 readOnly: false "; var obj = Yaml.LoadFromString <V1Pod>(content); Assert.True(obj.Spec.Containers[0].VolumeMounts[0].ReadOnlyProperty); Assert.False(obj.Spec.Containers[0].VolumeMounts[1].ReadOnlyProperty); }
public async System.Threading.Tasks.Task <IActionResult> Index(int id) { userName = this.User.FindFirstValue(ClaimTypes.NameIdentifier); var k8SClientConfig = KubernetesClientConfiguration.BuildDefaultConfig(); var client = new Kubernetes(k8SClientConfig); var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>(); optionsBuilder.UseSqlServer("ApplicationDbContext"); p = _context.Template.Find(id).Path; HttpContext.Session.SetInt32("TemplateId", id); var pDeployments = "/etc/athena/Templates/" + p + "/Deployment"; var pServices = "/etc/athena/Templates/" + p + "/Service"; var pIngress = "/etc/athena/Templates/" + p + "/Ingress"; string pNetPol = "/etc/athena/Templates/" + p + "/NetworkPolicy"; try { foreach (string file in Directory.EnumerateFiles(pServices)) { var fileContent = System.IO.File.ReadAllText(file); var service = Yaml.LoadFromString <V1Service>(fileContent); var result = client.CreateNamespacedService(service, userName); } foreach (string file in Directory.EnumerateFiles(pDeployments)) { var fileContent = System.IO.File.ReadAllText(file); var deployment = Yaml.LoadFromString <V1Deployment>(fileContent); var result = client.CreateNamespacedDeployment(deployment, userName); } foreach (string file in Directory.EnumerateFiles(pIngress)) { var fileContent = System.IO.File.ReadAllText(file); var ingress = Yaml.LoadFromString <Networkingv1beta1Ingress>(fileContent); AddIngress(client, ingress, userName); } foreach (string file in Directory.EnumerateFiles(pNetPol)) { V1NetworkPolicy netPol = null; var fileContent = System.IO.File.ReadAllText(file); netPol = Yaml.LoadFromString <V1NetworkPolicy>(fileContent); var result = client.CreateNamespacedNetworkPolicy(netPol, userName); } return(View()); } catch { return(View()); } }
public async Task <Networkingv1beta1Ingress> CreateNetworkingv1beta1IngressAsync( string networkingv1beta1IngressContent, string namespaceParameter = null, string ingressHostname = null, CancellationToken cancellationToken = default ) { if (string.IsNullOrWhiteSpace(networkingv1beta1IngressContent)) { throw new ArgumentNullException(nameof(networkingv1beta1IngressContent)); } try { Log.Verbose("Loading k8s Ingress definition ..."); var networkingv1beta1IngressDefinition = Yaml .LoadFromString <Networkingv1beta1Ingress>( networkingv1beta1IngressContent ); if (!string.IsNullOrWhiteSpace(namespaceParameter)) { networkingv1beta1IngressDefinition.Metadata.NamespaceProperty = namespaceParameter; } // If hostname is provided then we will update Spec if (!string.IsNullOrWhiteSpace(ingressHostname)) { // Add entry to Spec.Tls const string secretName = "tls-secret"; var tls = new Networkingv1beta1IngressTLS { Hosts = new List <string> { ingressHostname }, SecretName = secretName }; if (networkingv1beta1IngressDefinition.Spec.Tls is null) { networkingv1beta1IngressDefinition.Spec.Tls = new List <Networkingv1beta1IngressTLS> { tls }; } else { networkingv1beta1IngressDefinition.Spec.Tls.Add(tls); } // Set host in Spec.Rules[0] networkingv1beta1IngressDefinition.Spec.Rules.First().Host = ingressHostname; } Log.Verbose($"Creating k8s Ingress: " + $"{networkingv1beta1IngressDefinition.Metadata.Name} ..."); var networkingv1beta1Ingress = await _k8sClient .CreateNamespacedIngress1Async( networkingv1beta1IngressDefinition, networkingv1beta1IngressDefinition.Metadata.NamespaceProperty, cancellationToken : cancellationToken ); Log.Verbose($"Created k8s Ingress: {networkingv1beta1Ingress.Metadata.Name}"); return(networkingv1beta1Ingress); } catch (Exception ex) { Log.Error(ex, $"Failed to create k8s Ingress"); throw; } }
public IActionResult Index() { string a; var UserEmail = this.User.Identity.Name; var result = GetUserRoles(UserEmail, "*****@*****.**", out a); ViewBag.Tutor = a; ViewBag.Admin = result; if (a == "/Staff") { HttpContext.Session.SetString("Role", "staff"); } else { HttpContext.Session.SetString("Role", "student"); } var UserId = this.User.FindFirstValue(ClaimTypes.NameIdentifier); try { var k8SClientConfig = KubernetesClientConfiguration.BuildDefaultConfig(); var client = new Kubernetes(k8SClientConfig); var namespaces = client.ListNamespace(null, null, "metadata.name=" + UserId); if (namespaces != null && namespaces.Items.Count > 0) { return(View()); } var ns = new V1Namespace { Metadata = new V1ObjectMeta { Name = UserId } }; var result2 = client.CreateNamespace(ns); var netPolFile = "default-network-policy.yaml"; if (System.IO.File.Exists(netPolFile)) { var fileContent = System.IO.File.ReadAllText(netPolFile); var netPol = Yaml.LoadFromString <V1NetworkPolicy>(fileContent); client.CreateNamespacedNetworkPolicy(netPol, UserId); } ViewData["Message"] = ""; return(View()); } catch (Exception e) { return(RedirectToAction("Error", e)); } }
public bool CheckDeployments(IKubernetes client, IDeserializer deserializer, string path, string key, out string value) { value = null; string curr; bool match = true; foreach (string file in Directory.EnumerateFiles(path)) { var fileContent = System.IO.File.ReadAllText(file); var deployment = Yaml.LoadFromString <V1Deployment>(fileContent); if (deployment == null) { match = false; break; } // Check if Deployment has label - if no labels return false if (deployment.Metadata.Labels != null) { deployment.Metadata.Labels.TryGetValue(key, out curr); } else { match = false; break; } // Matches first Deployment with label, assigns label value to labName if (value == null) { value = curr; } // If there is no match at this stage, there is a mismatch else if (value != curr) { match = false; break; } // Checking selectors - all deployments must select based on at least the lab name and that name must match on every template // Checking MatchLabels if (deployment.Spec.Selector.MatchLabels != null) { deployment.Spec.Selector.MatchLabels.TryGetValue(key, out curr); if (value != curr) { match = false; break; } } // Checking MatchExpressions else { var expressions = deployment.Spec.Selector.MatchExpressions; if (expressions != null) { foreach (var expression in expressions) { if (expression.Key == key && expression.OperatorProperty == "In" && expression.Values.Contains(value)) { match = true; break; } else { match = false; break; } } } } // Checking Pod Spec - label should be present and correct if (deployment.Spec.Template.Metadata.Labels == null) { match = false; break; } deployment.Spec.Template.Metadata.Labels.TryGetValue(key, out curr); if (value != curr) { match = false; break; } } return(match); }