Allocate resources automatically to containers in a container app

Farmer.sln

@@ -1,7 +1,6 @@
-
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.29201.188
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.32002.185
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{6EC3EE1D-3C4E-46DD-8F32-0CC8E7565705}") = "Farmer", "src\Farmer\Farmer.fsproj", "{CB0287CC-AD12-427C-866B-5F236C29B0A2}"
 EndProject
@@ -18,6 +17,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "scripts", "scripts", "{C399
 		samples\scripts\appinsights.fsx = samples\scripts\appinsights.fsx
 		samples\scripts\bastion.fsx = samples\scripts\bastion.fsx
 		samples\scripts\cdn.fsx = samples\scripts\cdn.fsx
+		samples\scripts\container-app.fsx = samples\scripts\container-app.fsx
 		samples\scripts\container-group.fsx = samples\scripts\container-group.fsx
 		samples\scripts\container-instance-gpu.fsx = samples\scripts\container-instance-gpu.fsx
 		samples\scripts\container-instance.fsx = samples\scripts\container-instance.fsx

optimiser.fsx

@@ -0,0 +1,136 @@
+#r "nuget:FsCheck"
+
+open FsCheck
+open System
+
+type [<Measure>] Gb
+type [<Measure>] VCores
+
+let resourceMinimums =
+    [
+        0.25<VCores>, 0.5<Gb>
+        0.5<VCores>, 1.0<Gb>
+        0.75<VCores>, 1.5<Gb>
+        1.0<VCores>, 2.0<Gb>
+        1.25<VCores>, 2.5<Gb>
+        1.5<VCores>, 3.0<Gb>
+        1.75<VCores>, 3.5<Gb>
+        2.0<VCores>, 4.<Gb>
+    ]
+
+
+let cores = 1.75
+let containers = 5.
+
+
+let optimise containers (cores:float<VCores>, memory:float<Gb>) =
+    let containers = float containers
+    let minCores = resourceMinimums |> List.tryFind (fun (cores, _) -> float cores > containers * 0.05) |> Option.map fst
+    let minRam = resourceMinimums |> List.tryFind (fun (_, ram) -> float ram > containers * 0.01) |> Option.map snd
+    match minCores, minRam with
+    | Some minCores, Some minRam ->
+        if minCores > cores then Error $"Insufficient cores (minimum is {minCores}VCores)."
+        elif minRam > memory then Error $"Insufficient memory (minimum is {minRam}Gb)."
+        else
+            let cores = float cores
+            let memory = float memory
+
+            let vcoresPerContainer = Math.Truncate ((cores / containers) * 20.) / 20.
+            let remainingCores = cores - (vcoresPerContainer * containers)
+
+            let gbPerContainer = Math.Truncate ((memory / containers) * 100.) / 100.
+            let remainingGb = memory - (gbPerContainer * containers)
+
+            Ok [
+                for container in 1. .. containers do
+                    if container = 1. then
+                        (vcoresPerContainer + remainingCores) * 1.<VCores>, (gbPerContainer + remainingGb) * 1.<Gb>
+                    else
+                        vcoresPerContainer * 1.<VCores>, gbPerContainer * 1.<Gb>
+            ]
+    | None, _ ->
+        Error "Insufficient cores"
+    | _, None ->
+        Error "Insufficient memory"
+
+// Usage
+optimise 4 (1.0<VCores>, 4.<Gb>)
+
+
+
+
+
+
+
+
+
+
+
+
+
+type Inputs = PositiveInt * float<VCores> * float<Gb>
+type ValidInput = ValidInput of Inputs
+type InvalidInput = InvalidInput of Inputs
+
+type Tests =
+    static member totalsAlwaysEqualInput (ValidInput(PositiveInt containers, cores, memory)) =
+        let split = optimise containers (cores, memory)
+        match split with
+        | Ok split ->
+            let correctCores = split |> List.sumBy fst |> decimal = decimal cores
+            let correctRam = split |> List.sumBy snd |> decimal = decimal memory
+            correctCores && correctRam
+        | Error msg ->
+            failwith msg
+
+    static member givesBackCorrectNumberOfConfigs (ValidInput(PositiveInt containers, cores, memory)) =
+        let split = optimise containers (cores, memory)
+        match split with
+        | Ok split -> split.Length = containers
+        | Error msg -> failwith msg
+
+    static member neverReturnsLessThanMinimum (ValidInput(PositiveInt containers, cores, memory)) =
+        let split = optimise containers (cores, memory)
+        match split with
+        | Ok split -> split |> List.forall(fun (c, m) -> c >= 0.05<VCores> && m >= 0.01<Gb>)
+        | Error msg -> failwith msg
+
+    static member failsIfInputsInvalid (InvalidInput(PositiveInt containers, cores, memory)) =
+        let split = optimise containers (cores, memory)
+        match split with
+        | Ok _ -> failwith "Should have failed."
+        | Error _ -> true
+
+let basicGen = gen {
+    let! cores, gb = Gen.elements resourceMinimums
+    let! containers = Arb.Default.PositiveInt () |> Arb.filter(fun (PositiveInt s) -> s < 20) |> Arb.toGen
+    return containers, cores, gb
+}
+
+let shrinker checker (con:PositiveInt, cor, mem) =
+    [
+        if con.Get > 1 then PositiveInt (con.Get - 1), cor, mem
+        if cor > 0.25<VCores> then con, cor - 0.25<VCores>, mem - 0.5<Gb>
+    ]
+    |> List.filter checker
+
+type ResourceArb =
+    static member IsValid (PositiveInt con, cor, mem) =
+        let cores = resourceMinimums |> Seq.find(fun (cores, _) -> float cores > float con * 0.05) |> fst <= cor
+        let memory = resourceMinimums |> Seq.find(fun (_, mem) -> float mem > float con * 0.01) |> snd <= mem
+        cores && memory
+
+    static member ValidInputs () =
+        { new Arbitrary<ValidInput> () with
+            override _.Generator = basicGen |> Gen.filter ResourceArb.IsValid |> Gen.map ValidInput
+            override _.Shrinker (ValidInput inputs) = inputs |> shrinker ResourceArb.IsValid |> Seq.map ValidInput
+        }
+    static member InvalidInputs () =
+        { new Arbitrary<InvalidInput> () with
+            override _.Generator = basicGen |> Gen.filter (ResourceArb.IsValid >> not) |> Gen.map InvalidInput
+            override _.Shrinker (InvalidInput inputs) = inputs |> shrinker (ResourceArb.IsValid >> not) |> Seq.map InvalidInput
+        }
+
+let config = { Config.Default with Arbitrary = [ typeof<ResourceArb> ] }
+
+Check.All<Tests> config

samples/scripts/container-app.fsx

@@ -1,39 +1,38 @@
-#r @"..\..\src\Farmer\bin\Debug\net5.0\Farmer.dll"
+#r @"..\..\src\Farmer\bin\Debug\netstandard2.0\Farmer.dll"
 
 open Farmer
 open Farmer.Builders
 open Farmer.ContainerApp
-open System
 
 let queueName = "myqueue"
-let storageName = $"{Guid.NewGuid().ToString().[0..5]}containerqueue"
+let storageName = $"isaaccontainerqueue"
 let myStorageAccount = storageAccount {
     name storageName
     add_queue queueName
 }
 
 let env =
     containerEnvironment {
-        name $"containerenv{Guid.NewGuid().ToString().[0..5]}"
+        name $"containerenvisaac"
         add_containers [
-            containerApp {
-                name "aspnetsample"
-                add_simple_container "mcr.microsoft.com/dotnet/samples" "aspnetapp"
-                ingress_target_port 80us
-                ingress_transport Auto
-                add_http_scale_rule "http-scaler" { ConcurrentRequests = 10 }
-                add_cpu_scale_rule "cpu-scaler" { Utilisation = 50 }
-            }
             containerApp {
                 name "queuereaderapp"
+                allocate_resources ResourceLevels.``CPU = 1.75, RAM = 3.5``
                 add_containers [
+                    container {
+                        name "aspnetsample"
+                        public_docker_image "mcr.microsoft.com/dotnet/samples" "aspnetapp"
+                    }
                     container {
                         name "queuereaderapp"
-                        public_docker_image "mcr.microsoft.com/azuredocs/containerapps-queuereader" ""
-                        cpu_cores 1.0<VCores>
-                        memory 1.0<Gb>
+                        public_docker_image "mcr.microsoft.com/azuredocs/containerapps-queuereader" null
                     }
                 ]
+                ingress_target_port 80us
+                ingress_transport Auto
+                active_revision_mode ActiveRevisionsMode.Single
+                add_http_scale_rule "http-scaler" { ConcurrentRequests = 10 }
+                add_cpu_scale_rule "cpu-scaler" { Utilisation = 50 }
                 replicas 1 10
                 add_env_variable "QueueName" queueName
                 add_secret_expression "queueconnectionstring" myStorageAccount.Key
@@ -42,6 +41,8 @@ let env =
         ]
     }
 
+env.ContainerApps.[0].Containers
+
 let template =
     arm {
         location Location.NorthEurope

src/Farmer/Builders/Builders.ContainerApps.fs

@@ -32,7 +32,8 @@ type ContainerAppConfig =
       /// Credentials for image registries used by containers in this environment.
       ImageRegistryCredentials : ImageRegistryAuthentication list
       Containers : ContainerConfig list
-      Dependencies : Set<ResourceId> }
+      Dependencies : Set<ResourceId>
+      ResourceAllocation : ContainerAppResourceLevel option }
 
 type ContainerEnvironmentConfig =
     { Name : ResourceName
@@ -119,20 +120,48 @@ type ContainerEnvironmentBuilder() =
     /// Support for adding dependencies to this Container App Environment.
     interface IDependable<ContainerEnvironmentConfig> with member _.Add state newDeps = { state with Dependencies = state.Dependencies + newDeps }
 
-let private supportedResourceCombinations =
-    Set [
-        0.25<VCores>, 0.5<Gb>
-        0.5<VCores>, 1.0<Gb>
-        0.75<VCores>, 1.5<Gb>
-        1.0<VCores>, 2.0<Gb>
-        1.25<VCores>, 2.5<Gb>
-        1.5<VCores>, 3.0<Gb>
-        1.75<VCores>, 3.5<Gb>
-        2.0<VCores>, 4.<Gb>
-    ]
-
 let private defaultResources = {| CPU = 0.25<VCores>; Memory = 0.5<Gb> |}
 
+[<System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)>]
+module ResourceOptimisation =
+    open System
+    let supportedResourceCombinations = ResourceLevels.AllLevels |> Set.toList
+    let MIN_CORE_SIZE = 0.05
+    let MIN_RAM_SIZE = 0.01
+
+    let optimise (containers:int) (cores:float<VCores>, memory:float<Gb>) =
+        let containers = float containers
+        let requiredMinCores = supportedResourceCombinations |> List.map (fun (ContainerAppResourceLevel (cores, _)) -> cores) |> List.tryFind (fun cores -> float cores > containers * MIN_CORE_SIZE)
+        let requiredMinRam = supportedResourceCombinations |> List.map (fun (ContainerAppResourceLevel (_, ram)) -> ram) |> List.tryFind (fun ram -> float ram > containers * MIN_RAM_SIZE)
+
+        match requiredMinCores, requiredMinRam with
+        | Some minCores, Some minRam ->
+            if minCores > cores then Error $"Insufficient cores (minimum is {minCores}VCores)."
+            elif minRam > memory then Error $"Insufficient memory (minimum is {minRam}Gb)."
+            else
+                let cores = float cores
+                let memory = float memory
+
+                let vcoresPerContainer = Math.Truncate ((cores / containers) * 20.) / 20.
+                let remainingCores = cores - (vcoresPerContainer * containers)
+
+                let gbPerContainer = Math.Truncate ((memory / containers) * 100.) / 100.
+                let remainingGb = memory - (gbPerContainer * containers)
+
+                Ok [
+                    for container in 1. .. containers do
+                        if container = 1. then
+                            {| CPU = (vcoresPerContainer + remainingCores) * 1.<VCores>
+                               Memory = (gbPerContainer + remainingGb) * 1.<Gb> |}
+                        else
+                            {| CPU = vcoresPerContainer * 1.<VCores>
+                               Memory = gbPerContainer * 1.<Gb> |}
+                ]
+        | None, _ ->
+            Error "Insufficient cores"
+        | _, None ->
+            Error "Insufficient memory"
+
 type ContainerAppBuilder () =
     member _.Yield _ =
         { Name = ResourceName.Empty
@@ -145,27 +174,50 @@ type ContainerAppBuilder () =
           IngressMode = None
           EnvironmentVariables = Map.empty
           DaprConfig = None
-          Dependencies = Set.empty }
-
+          Dependencies = Set.empty
+          ResourceAllocation = None }
 
     member _.Run (state:ContainerAppConfig) =
+        let state =
+            match state.ResourceAllocation with
+            | Some (ContainerAppResourceLevel (cores, memory)) ->
+                if state.Containers |> List.exists (fun r -> r.Resources <> defaultResources) then
+                    raiseFarmer "You have set resource allocation at the Container App level, but also set the resource levels of some individual containers. If you are using Container App Resource Allocation, you cannot set resources of individual containers."
+
+                let split = ResourceOptimisation.optimise state.Containers.Length (cores, memory)
+                match split with
+                | Ok resources ->
+                    let containersAndResources = List.zip state.Containers resources
+
+                    { state with
+                        Containers = [
+                            for (container, resources) in containersAndResources do
+                                { container with Resources = resources }
+                        ]
+                    }
+                | Error msg ->
+                    raiseFarmer msg
+            | None ->
+                state
+
         let resourceTotals =
             state.Containers
             |> List.fold (fun (cpu, ram) container ->
                 cpu + container.Resources.CPU, ram + container.Resources.Memory
             ) (0.<VCores>, 0.<Gb>)
+            |> ContainerAppResourceLevel
 
-        let describe (cpu, ram) = $"({cpu}VCores, {ram}Gb)"
-        if not (supportedResourceCombinations.Contains resourceTotals) then
-            let supported = Set.toList supportedResourceCombinations |> List.map describe |> String.concat "; "
+        let describe (ContainerAppResourceLevel (cpu, ram)) = $"({cpu}VCores, {ram}Gb)"
+        if not (ResourceLevels.AllLevels.Contains resourceTotals) then
+            let supported = Set.toList ResourceLevels.AllLevels |> List.map describe |> String.concat "; "
             raiseFarmer $"The container app '{state.Name.Value}' has an invalid combination of CPU and Memory {describe resourceTotals}. All the containers within a container app must have a combined CPU & RAM combination that matches one of the following: [ {supported} ]."
 
         state
 
     /// Sets the name of the Azure Container App.
     [<CustomOperation "name">]
-    member _.ResourceName (state:ContainerAppConfig, name:string) = { state with Name = ResourceName name }
-
+    member _.ResourceName (state:ContainerAppConfig, name:string) =
+        { state with Name = ResourceName name }
     /// Adds a scale rule to the Azure Container App.
     [<CustomOperation "add_http_scale_rule">]
     member _.AddHttpScaleRule (state:ContainerAppConfig, name, rule:HttpScaleRule) =
@@ -307,14 +359,21 @@ type ContainerAppBuilder () =
             }
         this.AddContainers(state, [ container ])
 
+    [<CustomOperation "allocate_resources">]
+    /// Allocates resources equally to all containers in the container app.
+    member _.ShareResources (state:ContainerAppConfig, resourceLevel:ContainerAppResourceLevel) =
+        { state with ResourceAllocation = Some resourceLevel }
+
     /// Support for adding dependencies to this Container App.
-    interface IDependable<ContainerAppConfig> with member _.Add state newDeps = { state with Dependencies = state.Dependencies + newDeps }
+    interface IDependable<ContainerAppConfig> with
+        member _.Add state newDeps = { state with Dependencies = state.Dependencies + newDeps }
 
 type ContainerBuilder () =
     member _.Yield _ =
         { ContainerName = ""
           DockerImage = None
           Resources = defaultResources }
+
     /// Set docker credentials
     [<CustomOperation "name">]
     member _.ContainerName (state:ContainerConfig, name) =
@@ -345,6 +404,6 @@ type ContainerBuilder () =
         let roundedMemory = System.Math.Round(memory, 2) * 1.<Gb>
         { state with Resources = {| state.Resources with Memory = roundedMemory |} }
 
-let containerEnvironment = ContainerEnvironmentBuilder()
-let containerApp = ContainerAppBuilder()
-let container = ContainerBuilder()
+let containerEnvironment = ContainerEnvironmentBuilder ()
+let containerApp = ContainerAppBuilder ()
+let container = ContainerBuilder ()