Re: Help with a unikernel webserver

Hannes Mehnert Mon, 05 May 2025 00:27:57 -0700

Dear Miroslav,


thanks for reaching out.

So, your config.ml:
> open Mirage
> let stack = generic_stackv4v6 default_network
>
> let net = netif “secret”
> let secret_stack = generic_stackv4v6 net
> (* Main unikernel module *)
> let main =
>          main
>          ~packages:[package "cohttp-mirage"]
>          "Unikernel.Main"
>          (pclock @-> conduit @-> resolver @-> stackv4v6 @-> job)
>
> let () =

> register "frontend-server" [ main $ default_posix_clock $conduit_direct stack $ resolver_dns stack $ stack ]


Here, you'll need to use & provide the "secret_stack":

let main =
         main
         ~packages:[package "cohttp-mirage"]
         "Unikernel.Main"

(pclock @-> conduit @-> conduit @-> resolver @-> stackv4v6 @->job)


let () =

register "frontend-server" [ main $ default_posix_clock $conduit_direct stack $ conduit_direct secret_stack $ resolver_dnssecret_stack $ stack ]



Which will then result in your unikernel being a bit modified:
> module Main
>          (Pclock : Mirage_clock.PCLOCK)
>          (Conduit : Conduit_mirage.S)
>          (Resolver : Resolver_mirage.S)
>          (Stack : Tcpip.Stack.V4V6) = struct
>
>    module Client = Cohttp_mirage.Client.Make(Pclock)(Resolver)(Conduit)
>    module Server = Cohttp_mirage.Server.Make(Conduit)

will now be:

module Main
         (Pclock : Mirage_clock.PCLOCK)
         (Conduit : Conduit_mirage.S)
         (Secret_conduit : Conduit_mirage.S)
         (Secret_resolver : Resolver_mirage.S)
         (Stack : Tcpip.Stack.V4V6) = struct

module Client =Cohttp_mirage.Client.Make(Pclock)(Secret_resolver)(Secret_conduit)

   module Server = Cohttp_mirage.Server.Make(Conduit)


And then, also your "start" function is slightly adapted:
>    let start _pclock _conduit _resolver stack =

will be:
   let start _pclock _conduit _secret_conduit _secret_resolver stack =

And then your HTTP client will use the secret network stack, while theserver uses the default one.


Hope this helps,

Hannes


On 01/05/2025 22:58, Belej, Miroslav wrote:

Hi, I am developing a unikernel webserver for my thesis and I would be glad for 
help, as I am not really good with OCaml. I already have a running and 
functional webserver, which acts as proxy between user and backend. Right now, 
it uses the same tcp/ip stack for both the user and for forwarding and 
receiving request from backend. I need to have separate stack for both of them. 
I am using Cohttp_mirage library. Here is the code for the unikernel I 
currently have :
open Lwt.Infix


let target_host = "http://192.168.254.11";
let target_port = 8081

module Main
         (Pclock : Mirage_clock.PCLOCK)
         (Conduit : Conduit_mirage.S)
         (Resolver : Resolver_mirage.S)
         (Stack : Tcpip.Stack.V4V6) = struct

   module Client = Cohttp_mirage.Client.Make(Pclock)(Resolver)(Conduit)
   module Server = Cohttp_mirage.Server.Make(Conduit)
   (*Define the forwarding logic*)
   let forward_request uri body resolver conduit =
     let target_uri = Uri.of_string target_host in
     let target_uri = Uri.with_port target_uri (Some target_port) in
     let target_uri = Uri.with_path target_uri (Uri.path uri ) in
     Logs.info (fun f -> f "Forwarding to %s" (Uri.to_string target_uri));
     let headers = Cohttp.Header.init () in
     let body = Cohttp_lwt.Body.of_string body in

     let ctx = Client.ctx resolver conduit in

     Client.post ~ctx ~headers ~body target_uri >>= fun (resp, resp_body) ->
     Cohttp_lwt.Body.to_string resp_body >|= fun body_str ->
     Logs.info (fun f -> f "Received response from %s" (Uri.to_string 
target_uri));
     (resp, body_str)


   (* Define the HTTP server callback *)
   let server_callback _conn req body resolver conduit =
     let uri = Cohttp.Request.uri req in
     let method_ = Cohttp.Request.meth req in
     Logs.info (fun f ->
             f "Received %s request for %s"
             (Cohttp.Code.string_of_method method_)
             (Uri.to_string uri));
     Cohttp_lwt.Body.to_string body >>= fun body_str ->
     let response_body = "This will be hashed-> " ^ body_str in
     Logs.info (fun f -> f "Response Body: %s" response_body);
     forward_request uri body_str resolver conduit >>= fun (response, 
response_body) ->
     Logs.info (fun f -> f "Response body from forwarded request: %s" 
response_body);
     Lwt.return (response, Cohttp_lwt.Body.of_string response_body)


     (* Start the HTTP server *)
   let start _pclock _conduit _resolver stack =
     Logs.info (fun f -> f "Before port");
     let port = 8080 in
     Logs.info (fun f -> f "Defined port");
     Logs.info (fun f -> f "Starting MirageOS HTTP server on port %d" port);
     let callback _conn req body = server_callback _conn req body _resolver 
_conduit in
     let mode : Conduit_mirage.server = `TCP port in
     let server = Server.make ~callback () in

     Server.listen stack mode server
end

with config.ml :

open Mirage
let stack = generic_stackv4v6 default_network

let net = netif “secret”
let secret_stack = generic_stackv4v6 net
(* Main unikernel module *)
let main =
         main
         ~packages:[package "cohttp-mirage"]
         "Unikernel.Main"
         (pclock @-> conduit @-> resolver @-> stackv4v6 @-> job)

let () =
   register "frontend-server" [ main $ default_posix_clock $ conduit_direct 
stack $ resolver_dns stack $ stack ]

So I would like to use the secret_stack for communicating with the backend. I 
am thankful for any response.

Re: Help with a unikernel webserver

Reply via email to