public string CreateService(string tenant, string filename)
{
var yml = Yaml.LoadFromFileAsync <V1Service>(filename).Result;
yml.Metadata.Labels.Add("tenant", tenant);
yml.Spec.Selector.Add("tenant", tenant);
var svc = _client.CreateNamespacedService(yml, "default");
return(svc.Metadata.Name);
}
public ActionResult Create()
{
var id = Guid.NewGuid().ToString("N").Substring(0, 5);
var config = KubernetesClientConfiguration.BuildConfigFromConfigFile();
var client = new Kubernetes(config);
var service = client.CreateNamespacedService(ServiceModel.CreateService(id), "minecraft");
service.Validate();
try
{
client.CreateNamespacedStatefulSet(StatefulSetModel.CreateStatefulSet(id), "minecraft");
}
catch { }
var pod = client.CreateNamespacedPod(PodModel.CreatePod(id), "minecraft");
pod.Validate();
return(Created("/servers", new object[] { service, pod }));
}
public virtual IActionResult ServersPost(string servername)
{
Contract.Ensures(Contract.Result <IActionResult>() != null);
try
{
var config = KubernetesClientConfiguration.BuildConfigFromConfigFile();
IKubernetes client = new Kubernetes(config);
var deployment = ObterYaml <V1Deployment>(servername, "./aks-minecraft.yaml");
var services = ObterYaml <V1Service>(servername, "./services.yaml");
var newDeployment = client.CreateNamespacedDeployment(
body: deployment, namespaceParameter: "default");
var newServices = client.CreateNamespacedService(
body: services, namespaceParameter: "default");
string exampleJson = null;
exampleJson = "{\n \"endpoints\" : {\n \"minecraft\" : \"minecraft\",\n \"rcon\" : \"rcon\"\n },\n \"name\" : \"name\"\n}";
var example = exampleJson != null
? JsonConvert.DeserializeObject <Server>(exampleJson)
: default(Server);
return(new ObjectResult(newDeployment));
}
catch (Exception ex)
{
return(new ObjectResult(ex.Message));
}
}
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());
}
}
internal void AddServicePod(string podName)
{
podName = podName.ToLower();
var appLabel = new Dictionary <string, string> {
{ "app", podName }
};
using (Stream stream = KubeConfigStream)
{
var config = KubernetesClientConfiguration.BuildConfigFromConfigFile(stream);
using (IKubernetes client = new Kubernetes(config))
{
var deployment = new Appsv1beta1Deployment("apps/v1beta1", "Deployment")
{
Metadata = new V1ObjectMeta()
{
Name = podName
},
Spec = new Appsv1beta1DeploymentSpec()
{
Template = new V1PodTemplateSpec()
{
Metadata = new V1ObjectMeta()
{
Labels = appLabel
},
Spec = new V1PodSpec()
{
Containers = new k8s.Models.V1Container[] {
new V1Container
{
Name = podName,
Image = "openhackteam5.azurecr.io/minecraft-server:2.0",
VolumeMounts = new V1VolumeMount[]
{
new k8s.Models.V1VolumeMount
{
Name = "volume",
MountPath = "/data"
}
},
Ports = new V1ContainerPort[]
{
new V1ContainerPort(25565, name: "port25565"),
new V1ContainerPort(25575, name: "port25575")
},
Env = new V1EnvVar[] { new V1EnvVar("EULA", true.ToString()) }
}
},
Volumes = new V1Volume[]
{
new V1Volume("volume", persistentVolumeClaim: new V1PersistentVolumeClaimVolumeSource(podName + SuffixPVC))
},
ImagePullSecrets = new V1LocalObjectReference[] { new V1LocalObjectReference("acr-auth") }
}
}
}
};
var loadBalancer = new V1Service("v1", "Service")
{
Metadata = new V1ObjectMeta {
Name = podName + SuffixLoadBalancer
},
Spec = new V1ServiceSpec
{
Type = "LoadBalancer",
Ports = new V1ServicePort[] {
new V1ServicePort(25565, "port25565", targetPort: 25565),
new V1ServicePort(25575, "port25575", targetPort: 25575)
},
Selector = appLabel
}
};
var persistentVolumeClaim = new V1PersistentVolumeClaim()
{
Metadata = new V1ObjectMeta()
{
Name = podName + SuffixPVC, NamespaceProperty = DefaultNamespace
},
Spec = new V1PersistentVolumeClaimSpec
{
AccessModes = new string[] { "ReadWriteMany" },
StorageClassName = "azurefile",
Resources = new V1ResourceRequirements(requests: new Dictionary <string, ResourceQuantity> {
{ "storage", new ResourceQuantity("5Gi") }
})
},
Status = new V1PersistentVolumeClaimStatus()
};
var pvcs = client.ListDeploymentForAllNamespaces1();
client.CreateNamespacedPersistentVolumeClaim(persistentVolumeClaim, DefaultNamespace);
client.CreateNamespacedDeployment1(deployment, DefaultNamespace);
client.CreateNamespacedService(loadBalancer, DefaultNamespace);
}
}
}
public static Compute CreateCompute([ActivityTrigger] string caseNumber, ExecutionContext context, ILogger log)
{
log.LogInformation($"Creating compute for {caseNumber}.");
var homeDirectory = context.FunctionAppDirectory;
var compute = new Compute();
var config
= KubernetesClientConfiguration.BuildConfigFromConfigFile(Path.Combine(homeDirectory, "kubeconfig.json"));
config.ClientCertificateKeyStoreFlags = X509KeyStorageFlags.MachineKeySet
| X509KeyStorageFlags.PersistKeySet
| X509KeyStorageFlags.Exportable;
var client = new Kubernetes(config);
try
{
var name = $"dsirona-engine-ag-{caseNumber}";
var v1service = Yaml.LoadFromFileAsync <V1Service>(Path.Combine(homeDirectory, "engineService.yaml")).Result;
v1service.Metadata.Name = name;
v1service.Spec.Selector.Clear();
v1service.Spec.Selector.Add("app", name);
var service = client.CreateNamespacedService(v1service, "default");
var v1Deployment = Yaml.LoadFromFileAsync <V1Deployment>(Path.Combine(homeDirectory, "engineDeployment.yaml")).Result;
var v1PodTemplate = v1Deployment.Spec.Template;
v1PodTemplate.Spec.Containers[0].Name = name;
v1Deployment.Metadata.Name = name;
v1Deployment.Spec.Selector.MatchLabels.Clear();
v1Deployment.Spec.Selector.MatchLabels.Add("app", name);
v1Deployment.Spec.Template.Metadata.Labels.Clear();
v1Deployment.Spec.Template.Metadata.Labels.Add("app", name);
var deployment = client.CreateNamespacedDeployment(v1Deployment, "default");
HttpOperationResponse <V1PodList> pods;
V1Pod pod = null;
//TODO: Keep trying till the status of the pod is Running, implement timeout
for (int retry = 0; retry < 60; retry++)
{
pods = client.ListNamespacedPodWithHttpMessagesAsync("default", labelSelector: $"app={name}").Result;
pod = pods.Body.Items[0];
if (pod.Status.Phase == "Running")
{
break;
}
Task.Delay(1000);
}
//Console.WriteLine($"Host IP : { pod.Status.HostIP}, ports: {service.Spec.Ports[0].NodePort},{service.Spec.Ports[1].NodePort},{service.Spec.Ports[2].NodePort}");
compute.Key = name;
compute.IPAddress = pod.Status?.HostIP;
compute.Port = service.Spec.Ports[0].NodePort.ToString();
}
catch (Exception serviceException)
{
///TODO: Implement rollback
compute.Status = "Error";
compute.LastErrorMessage = serviceException.Message;
Console.Write(serviceException.Message);
}
compute.Status = "Healthy";
return(compute);
}