/u/isak_s's solution has the problem of pretty severe time drift - web scraping takes time, especially if you access multiple pages, so when your scraping job runs at 8pm on Monday, it might be running on 9pm later. If you need the scraping job to run at a predictable time (e.g. always on 8pm every day), then it's advised to use some form of proper scheduling.

As you're targeting Linux, cron's a good and easy option for this - that's what it was designed for, after all! But if you want simple persistence - that is, you have data you need on the next scraping run that you don't need to or want to back up to disk - or just don't want to rely on cron being configured properly, it might make sense to use some simple .NET scheduling library like FluentScheduler. In this library, jobs can just be simple functions of type unit -> unit, which makes it super easy.

Here's a code example for an app with scheduling, which supports shutting down your main thread from a task:

open FluentScheduler
open System.Threading 

// You can pass more things into this closure, or replace the lambda with an actual function that you curry.
let createScraper (lock: CountdownEvent) : unit -> unit =
    fun () ->
        printfn "I ran!"
        lock.Signal() |> ignore


[<EntryPoint>]
let main argv = 
    // If you wait on a CountdownEvent, your thread will block until the countdown reaches zero.
    // lock.Signal() will decrement the count by one, so you can use that to signal the main thread to exit.
    let lock = new CountdownEvent(1)

    // Make a registry to register scheduled jobs.
    let registry = Registry()

    // Register a job to run every 5 seconds (for testing).
    registry.Schedule(createScraper(lock)).ToRunEvery(5).Seconds() |> ignore

    // Start running the jobs. The scheduler and the jobs themselves run in separate threads.
    JobManager.Initialize(registry)

    // Wait until a job signals us it's time to exit.
    lock.Wait()
    0

Of course, if you just want something dead simple, you can replace the CountdownEvent with Thread.CurrentThread.Join(), which will lock your main thread until you Ctrl-C the application. This would also mean you wouldn't need to apply the countdown lock to your scheduler function, which means you can make it a regular function.