docker-http-https-echo VS httpbin

I do not have a documentation, but I do disaster recovery tests from time to time. This is how you can try it out:

- download the ISO of a linux distribution, Arch is good because you have continuous updates (there is no "version")

- start it on a VM engine (VirtualBox, Hybersomething in Windows, VMWare, ...)

- from that point on - start documenting

- try to on docker install a program you know that is not too complex network-wise or just start with "hello-world" (https://hub.docker.com/_/hello-world)

- you will find that when running "docker pull hello-world", docker is not installed

- install docker on Arch according to Arch docs. DOCUMENT that step

- retry, hello-world works

- now try something like https://github.com/mendhak/docker-http-https-echo

- you will learn the basics of docker networking, read some docs or just try until you have a curl call working

- at that point you can try a program you know (nextcloud, syncting, ...), pulling it from docker hub and make it work. pay attention to two things: the network and the persistent volumes (I recommend, at least for the start, the file-based ones, not the docker ones)

- grab a beer, you are 90% done, good work

- have a close look at Caddy - this is a web server similar to apache, nginx but MUCH much better. So much better that I have no words.

- you will use it as a proxy server for your containers, so that you can get to them via https://nextcloud.yourdomain.com. It os worthwhile to get your domain even if you do not expose anything because things are much easier that way (caddy will manage the TLS part)

- now learn docker-compose and add all your dockers to it (it is a YAML description of your containers).

- add backup, this will be easier if you add this program on the OS itself (it can sure be in a container but I preferred having that part independent). I recommend Borg despite its few poor choices in the design (that are not likely to bite you at that point)

TADAM! you are done.

You are independent of th eOS, if you want to install fedora or whatever it just doe snot matter because i) all your programs are maintained by someone else (than you to the maintainers, it is nice to donate sometimes) and ii) your backup is data that is easily pluggable back to a ne instance of the software

Testing new programs is super easy (you just add them to the doclker compose YAML).

I truly recommend you try with a VM and you will quickly realize it is time to reformat your server and put everything under docker :) AMA if you have questions.

policyDefinitions: cors: origin: "${CLIENT_URL}" endpoints: - path: "/example" target: url: "https://httpbin.org/bearer" request: headers: Authorization: "Bearer ${API_KEY}" policies: - cors

We proceed to define routes to https://httpbin.org/ to test our setup. Let's call the route to /get:

https://httpbin.org/ is an excellent tool for learning (and testing) the basics. Take a few minutes to explore the endpoints they provide. You can also use different response codes to test your apps error handling, etc

export FABI_PROD="http://httpbin.org/" export FABI_LOCAL="http://0.0.0.0:8000/"

use anyhow; use embedded_svc::http::client::Client; use embedded_svc::wifi::{AuthMethod, ClientConfiguration, Configuration}; use esp_idf_hal::peripherals::Peripherals; use esp_idf_svc::eventloop::EspSystemEventLoop; use esp_idf_svc::http::client::{Configuration as HttpConfig, EspHttpConnection}; use esp_idf_svc::nvs::EspDefaultNvsPartition; use esp_idf_svc::wifi::{BlockingWifi, EspWifi}; fn main() -> anyhow::Result<()> { esp_idf_sys::link_patches(); // Configure Wifi let peripherals = Peripherals::take().unwrap(); let sysloop = EspSystemEventLoop::take()?; let nvs = EspDefaultNvsPartition::take()?; let mut wifi = BlockingWifi::wrap( EspWifi::new(peripherals.modem, sysloop.clone(), Some(nvs))?, sysloop, )?; wifi.set_configuration(&Configuration::Client(ClientConfiguration { ssid: "SSID".into(), bssid: None, auth_method: AuthMethod::None, password: "PASSWORD".into(), channel: None, }))?; // Start Wifi wifi.start()?; // Connect Wifi wifi.connect()?; // Wait until the network interface is up wifi.wait_netif_up()?; // Print Out Wifi Connection Configuration while !wifi.is_connected().unwrap() { // Get and print connection configuration let config = wifi.get_configuration().unwrap(); println!("Waiting for station {:?}", config); } println!("Wifi Connected, Intiatlizing HTTP"); // HTTP Configuration // Create HTTPS Connection Handle let httpconnection = EspHttpConnection::new(&HttpConfig { use_global_ca_store: true, crt_bundle_attach: Some(esp_idf_sys::esp_crt_bundle_attach), ..Default::default() })?; // Create HTTPS Client let mut httpclient = Client::wrap(httpconnection); // HTTP Request Submission // Define URL let url = "https://httpbin.org/get"; // Prepare request let request = httpclient.get(url)?; // Log URL and type of request println!("-> GET {}", url); // Submit Request and Store Response let response = request.submit()?; // HTTP Response Processing let status = response.status(); println!("<- {}", status); match response.header("Content-Length") { Some(data) => { println!("Content-Length: {}", data); } None => { println!("No Content-Length Header"); } } match response.header("Date") { Some(data) => { println!("Date: {}", data); } None => { println!("No Date Header"); } } Ok(()) }

has_domain: whether the matched route references an upstream with a domain, e.g., http://httpbin.org, or not, e.g., 192.168.0.1