private async Task Deploy(string name, string image, string nameSpace, int min, int max)
{
var isHTTP = IsHTTPTrigger(name);
await CreateNamespace(nameSpace);
ColoredConsole.WriteLine();
ColoredConsole.WriteLine("Deploying function to Knative...");
var knativeService = GetKnativeService(name, image, nameSpace, min, max, isHTTP);
await KubectlHelper.KubectlApply(knativeService, true);
var endpoint = await GetIstioClusterIngressEndpoint();
var host = GetFunctionHost(name, nameSpace);
ColoredConsole.WriteLine();
ColoredConsole.WriteLine("Function deployed successfully!");
ColoredConsole.WriteLine();
if (string.IsNullOrEmpty(endpoint))
{
ColoredConsole.WriteLine($"Function URL: http://{endpoint}");
}
else
{
ColoredConsole.WriteLine("Couldn't identify Function URL: Couldn't find Istio Cluster Ingress endpoint");
}
ColoredConsole.WriteLine($"Function Host: {host}");
ColoredConsole.WriteLine();
ColoredConsole.WriteLine("Plese note: it may take a few minutes for the knative service to be reachable");
}
public async override Task RunAsync()
{
if (DryRun)
{
ColoredConsole.WriteLine(KubernetesHelper.GetKedaResources(Namespace));
if (!KedaOnly)
{
ColoredConsole.WriteLine(KubernetesHelper.GetOsirisResources(Namespace));
}
}
else
{
var sb = new StringBuilder();
sb.AppendLine(KubernetesHelper.GetKedaResources(Namespace));
if (!KedaOnly)
{
sb.AppendLine(KubernetesHelper.GetOsirisResources(Namespace));
}
if (!await KubernetesHelper.NamespaceExists(Namespace))
{
await KubernetesHelper.CreateNamespace(Namespace);
}
await KubectlHelper.KubectlApply(sb.ToString(), showOutput : true);
}
}
private async Task Deploy(string name, string image, string nameSpace, int min, int max, double cpu, int memory, string port, string pullSecret)
{
await CreateNamespace(nameSpace);
var deploymentName = $"{name}-deployment";
await DeleteDeploymentIfExists(deploymentName, nameSpace);
ColoredConsole.WriteLine("Deploying function to Kubernetes...");
var deployment = GetDeployment(deploymentName, image, cpu, memory, port, nameSpace, min, pullSecret);
var json = Newtonsoft.Json.JsonConvert.SerializeObject(deployment,
Newtonsoft.Json.Formatting.None,
new Newtonsoft.Json.JsonSerializerSettings
{
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
});
await KubectlHelper.RunKubectl($"apply -f deployment.json --namespace {nameSpace}");
ColoredConsole.WriteLine("Deployment successful");
var service = GetService(deploymentName, nameSpace, port);
try
{
// we can safely ignore the error here
await KubectlHelper.KubectlApply(service, showOutput : false);
}
catch { }
await TryRemoveAutoscaler(deploymentName, nameSpace);
await CreateAutoscaler(deploymentName, nameSpace, min, max);
var externalIP = "";
ColoredConsole.WriteLine("Waiting for External IP...");
while (string.IsNullOrEmpty(externalIP))
{
var svc = await KubectlHelper.KubectlGet <JObject>($"{deploymentName}-service --namespace {nameSpace}");
if (svc != null)
{
var obj = svc.SelectToken("Status.LoadBalancer.Ingress[0].Ip");
if (obj != null)
{
externalIP = obj.ToString();
}
}
}
ColoredConsole.WriteLine();
ColoredConsole.WriteLine("Function deployed successfully!");
ColoredConsole.WriteLine($"Function IP: {externalIP}");
}
public async override Task RunAsync()
{
if (DryRun)
{
ColoredConsole.WriteLine(KubernetesHelper.GetKedaResources(Namespace));
}
else
{
if (!await KubernetesHelper.NamespaceExists(Namespace))
{
await KubernetesHelper.CreateNamespace(Namespace);
}
await KubectlHelper.KubectlApply(KubernetesHelper.GetKedaResources(Namespace), showOutput : true);
}
}
public override async Task RunAsync()
{
(var resolvedImageName, var shouldBuild) = ResolveImageName();
TriggersPayload triggers = null;
if (DryRun)
{
if (shouldBuild)
{
// don't build on a --dry-run.
// read files from the local dir
triggers = await GetTriggersLocalFiles();
}
else
{
triggers = await DockerHelpers.GetTriggersFromDockerImage(resolvedImageName);
}
}
else
{
if (shouldBuild)
{
await DockerHelpers.DockerBuild(resolvedImageName, Environment.CurrentDirectory);
}
triggers = await DockerHelpers.GetTriggersFromDockerImage(resolvedImageName);
}
(var resources, var funcKeys) = await KubernetesHelper.GetFunctionsDeploymentResources(
Name,
resolvedImageName,
Namespace,
triggers,
_secretsManager.GetSecrets(),
PullSecret,
SecretsCollectionName,
ConfigMapName,
UseConfigMap,
PollingInterval,
CooldownPeriod,
ServiceType,
MinReplicaCount,
MaxReplicaCount,
KeysSecretCollectionName,
MountFuncKeysAsContainerVolume);
if (DryRun)
{
ColoredConsole.WriteLine(KubernetesHelper.SerializeResources(resources, OutputSerializationOptions.Yaml));
}
else
{
if (!await KubernetesHelper.NamespaceExists(Namespace))
{
await KubernetesHelper.CreateNamespace(Namespace);
}
if (shouldBuild)
{
await DockerHelpers.DockerPush(resolvedImageName);
}
foreach (var resource in resources)
{
await KubectlHelper.KubectlApply(resource, showOutput : true, ignoreError : IgnoreErrors, @namespace : Namespace);
}
//Print the function keys message to the console
await KubernetesHelper.PrintFunctionsInfo($"{Name}-http", Namespace, funcKeys, triggers);
}
}
