From bef5c1d04e04f7b37187fc449818da1ff9571ba6 Mon Sep 17 00:00:00 2001
From: Graeme Byrne <grmbrn89@gmail.com>
Date: Thu, 5 Sep 2024 19:31:29 +0200
Subject: [PATCH] add blog posts to v2

---
 src/lib/v2/components/atoms/Cards.svelte      |    2 +
 .../components/molecules/BlogPostCard.svelte  |    2 +-
 .../components/singletons/RecentPosts.svelte  |   15 +-
 .../v2/components/singletons/SearchBar.svelte |    2 +-
 .../v2/(blog-article)/+layout.server.ts       |   12 +
 src/routes/v2/(blog-article)/+layout.svelte   |  208 +++
 .../+page.md                                  |  621 +++++++++
 .../+page.md                                  | 1064 +++++++++++++++
 .../deploying-torrust-to-production/+page.md  | 1146 +++++++++++++++++
 .../+page.md                                  |  151 +++
 .../how-to-contribute-to-this-site/+page.md   |   89 ++
 .../how-to-run-a-local-demo/+page.md          |  159 +++
 .../+page.md                                  |  409 ++++++
 .../+page.md                                  |  144 +++
 .../(blog-article)/live-demo-beta-v3/+page.md |   85 ++
 .../+page.md                                  |  339 +++++
 .../released-v3-0-0-alpha-12/+page.md         |  103 ++
 .../released-v3-0-0-beta/+page.md             |   87 ++
 .../+page.md                                  |  385 ++++++
 .../+page.md                                  |  234 ++++
 .../+page.md                                  |  199 +++
 .../what-is-a-bittorrent-tracker/+page.md     |  118 ++
 src/routes/v2/(waves)/+page.svelte            |   10 +
 23 files changed, 5568 insertions(+), 16 deletions(-)
 create mode 100644 src/routes/v2/(blog-article)/+layout.server.ts
 create mode 100644 src/routes/v2/(blog-article)/+layout.svelte
 create mode 100644 src/routes/v2/(blog-article)/benchmarking-the-torrust-bittorrent-tracker/+page.md
 create mode 100644 src/routes/v2/(blog-article)/containerizing-rust-applications-best-practices/+page.md
 create mode 100644 src/routes/v2/(blog-article)/deploying-torrust-to-production/+page.md
 create mode 100644 src/routes/v2/(blog-article)/hash2torrent-retrieve-torrent-files-effortlessly/+page.md
 create mode 100644 src/routes/v2/(blog-article)/how-to-contribute-to-this-site/+page.md
 create mode 100644 src/routes/v2/(blog-article)/how-to-run-a-local-demo/+page.md
 create mode 100644 src/routes/v2/(blog-article)/how-to-setup-the-development-environment/+page.md
 create mode 100644 src/routes/v2/(blog-article)/introducing-the-new-sample-torrent-migration-tool/+page.md
 create mode 100644 src/routes/v2/(blog-article)/live-demo-beta-v3/+page.md
 create mode 100644 src/routes/v2/(blog-article)/profiling-the-torrust-bittorrent-udp-tracker/+page.md
 create mode 100644 src/routes/v2/(blog-article)/released-v3-0-0-alpha-12/+page.md
 create mode 100644 src/routes/v2/(blog-article)/released-v3-0-0-beta/+page.md
 create mode 100644 src/routes/v2/(blog-article)/review-and-setup-guide-for-unit3d/+page.md
 create mode 100644 src/routes/v2/(blog-article)/the-enigmatic-torrent-source-field/+page.md
 create mode 100644 src/routes/v2/(blog-article)/torrust-enhancing-the-bittorrent-ecosystem/+page.md
 create mode 100644 src/routes/v2/(blog-article)/what-is-a-bittorrent-tracker/+page.md

diff --git a/src/lib/v2/components/atoms/Cards.svelte b/src/lib/v2/components/atoms/Cards.svelte
index 3c4d17b..4a938ca 100644
--- a/src/lib/v2/components/atoms/Cards.svelte
+++ b/src/lib/v2/components/atoms/Cards.svelte
@@ -41,6 +41,8 @@
 </svelte:element>
 
 <style lang="scss">
+	@import '$lib/scss/breakpoints.scss';
+
 	.body {
 		display: flex;
 		align-items: flex-end;
diff --git a/src/lib/v2/components/molecules/BlogPostCard.svelte b/src/lib/v2/components/molecules/BlogPostCard.svelte
index 41cf0cf..dcae44b 100644
--- a/src/lib/v2/components/molecules/BlogPostCard.svelte
+++ b/src/lib/v2/components/molecules/BlogPostCard.svelte
@@ -15,7 +15,7 @@
 </script>
 
 <Cards
-	href="/{slug}"
+	href="/v2/{slug}"
 	target="_self"
 	additionalClass="blog-post-card {!showImage || !coverImage ? 'no-image' : ''}"
 >
diff --git a/src/lib/v2/components/singletons/RecentPosts.svelte b/src/lib/v2/components/singletons/RecentPosts.svelte
index 15bc428..93216cf 100644
--- a/src/lib/v2/components/singletons/RecentPosts.svelte
+++ b/src/lib/v2/components/singletons/RecentPosts.svelte
@@ -18,9 +18,6 @@
 			/>
 		{/each}
 	</div>
-	<div class="link-container">
-		<a href="/blog">All articles</a>
-	</div>
 </div>
 
 <style lang="scss">
@@ -34,16 +31,6 @@
 			padding-top: 4rem;
 			text-align: center;
 		}
-
-		.link-container {
-			text-align: center;
-			padding-top: 3rem;
-		}
-
-		a {
-			color: white;
-			text-decoration: none;
-		}
 	}
 
 	.grid {
@@ -59,7 +46,7 @@
 		}
 
 		@include for-tablet-landscape-up {
-			grid-template-columns: 1fr 1fr 1fr;
+			grid-template-columns: 1fr 1fr;
 		}
 	}
 </style>
diff --git a/src/lib/v2/components/singletons/SearchBar.svelte b/src/lib/v2/components/singletons/SearchBar.svelte
index 0689561..1bc1fc2 100644
--- a/src/lib/v2/components/singletons/SearchBar.svelte
+++ b/src/lib/v2/components/singletons/SearchBar.svelte
@@ -91,7 +91,7 @@
 				<ul>
 					{#each results as result}
 						<li>
-							<a href="/{result.slug}" on:click={clearSearch}>
+							<a href="/v2/{result.slug}" on:click={clearSearch}>
 								<div>
 									<div>
 										<!-- eslint-disable-next-line svelte/no-at-html-tags -->
diff --git a/src/routes/v2/(blog-article)/+layout.server.ts b/src/routes/v2/(blog-article)/+layout.server.ts
new file mode 100644
index 0000000..c096472
--- /dev/null
+++ b/src/routes/v2/(blog-article)/+layout.server.ts
@@ -0,0 +1,12 @@
+import { filteredPosts } from '$lib/data/blog-posts';
+
+export async function load({ url }: { url: { pathname: string } }) {
+	const { pathname } = url;
+	const slug = pathname.replace('/v2/', '');
+	const post = filteredPosts.find((post) => post.slug === slug);
+
+	return {
+		post,
+		allPosts: filteredPosts
+	};
+}
diff --git a/src/routes/v2/(blog-article)/+layout.svelte b/src/routes/v2/(blog-article)/+layout.svelte
new file mode 100644
index 0000000..ca94b70
--- /dev/null
+++ b/src/routes/v2/(blog-article)/+layout.svelte
@@ -0,0 +1,208 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import Tag from '$lib/components/atoms/Tag.svelte';
+	import { formatDate } from '$lib/utils/date';
+	import ShareButton from '$lib/components/singletons/ShareButton.svelte';
+
+	import { keywords, siteBaseUrl, title } from '$lib/data/meta';
+	import type { BlogPost } from '$lib/utils/types';
+	import RelatedPosts from '$lib/components/organisms/RelatedPosts.svelte';
+	import Image from '$lib/components/atoms/Image.svelte';
+	import PrevNextPost from '$lib/components/singletons/PrevNextPost.svelte';
+	import { allPosts } from '$lib/data/blog-posts';
+	import Header from '$lib/v2/components/organisms/Header.svelte';
+	import Footer from '$lib/v2/components/organisms/Footer.svelte';
+
+	export let data: { post: BlogPost; allPosts: BlogPost[] };
+	let post: BlogPost;
+
+	$: ({ post } = data);
+
+	onMount(() => {
+		console.log('Current post:', post);
+		console.log('All posts:', allPosts[0]);
+	});
+
+	let metaKeywords = keywords;
+
+	$: {
+		if (post?.tags?.length) {
+			metaKeywords = post.tags.concat(metaKeywords);
+		}
+		if (post?.keywords?.length) {
+			metaKeywords = post.keywords.concat(metaKeywords);
+		}
+	}
+</script>
+
+<svelte:head>
+	{#if post}
+		<meta name="keywords" content={metaKeywords.join(', ')} />
+
+		<meta name="description" content={post.excerpt} />
+		<meta property="og:description" content={post.excerpt} />
+		<meta name="twitter:description" content={post.excerpt} />
+		<link rel="canonical" href="{siteBaseUrl}/{post.slug}" />
+
+		<title>{post.title} - {title}</title>
+		<meta property="og:title" content="{post.title} - {title}" />
+		<meta name="twitter:title" content="{post.title} - {title}" />
+
+		{#if post.coverImage}
+			<meta property="og:image" content="{siteBaseUrl}{post.coverImage}" />
+			<meta name="twitter:image" content="{siteBaseUrl}{post.coverImage}" />
+		{/if}
+	{/if}
+</svelte:head>
+
+<Header />
+<div class="container">
+	<main>
+		<article id="article-content">
+			<div class="header">
+				{#if post}
+					<h1>{post.title}</h1>
+					<div class="note">Published on {formatDate(post.date)}</div>
+					{#if post.updated}
+						<div class="note">Updated on {formatDate(post.updated)}</div>
+					{/if}
+					{#if post.readingTime}
+						<div class="note">{post.readingTime}</div>
+					{/if}
+					{#if post.contributor}
+						<div>
+							<span>By: </span><a href="/{post.contributorSlug}">{post.contributor}</a>
+						</div>
+					{/if}
+					<ShareButton slug={post.slug} title={post.title} />
+					{#if post.tags?.length}
+						<div class="tags">
+							{#each post.tags as tag}
+								<Tag {tag}>
+									{tag}
+								</Tag>
+							{/each}
+						</div>
+					{/if}
+				{/if}
+			</div>
+			{#if post && post.coverImage}
+				<div class="cover-image">
+					<Image src={post.coverImage} alt={post.title} />
+				</div>
+			{/if}
+			<div class="content">
+				<slot />
+			</div>
+		</article>
+
+		<PrevNextPost currentPost={post} {allPosts} />
+
+		{#if post.relatedPosts && post.relatedPosts.length > 0}
+			<div class="container">
+				<RelatedPosts posts={post.relatedPosts} />
+			</div>
+		{/if}
+	</main>
+</div>
+<Footer />
+
+<style lang="scss">
+	@import '$lib/scss/_mixins.scss';
+	@import '$lib/scss/breakpoints.scss';
+
+	.container {
+		background: rgba(26, 26, 26, 1);
+		color: rgba(245, 245, 245, 0.96);
+	}
+
+	#article-content {
+		--main-column-width: 65ch;
+		position: relative;
+		padding-top: 40px;
+		padding-bottom: 80px;
+		padding-right: 15px;
+		padding-left: 15px;
+
+		.cover-image {
+			padding-top: 1.5rem;
+		}
+
+		@include for-iphone-se {
+			padding-left: 0;
+			padding-right: 0;
+		}
+
+		@include for-tablet-portrait-up {
+			padding-right: 20px;
+			padding-left: 20px;
+		}
+
+		@include for-tablet-landscape-up {
+			--main-column-width: 170ch;
+			padding-right: 30px;
+			padding-left: 30px;
+		}
+
+		display: flex;
+		flex-direction: column;
+		gap: 30px;
+
+		.header {
+			display: flex;
+			flex-direction: column;
+			align-items: center;
+			justify-content: center;
+			text-align: center;
+			gap: 10px;
+			width: min(var(--main-column-width), 100%);
+			margin: 0 auto;
+
+			.note {
+				font-size: 90%;
+				color: rgba(var(--color--text-rgb), 0.8);
+			}
+		}
+
+		.cover-image {
+			width: min(var(--main-column-width), 100%);
+			margin: 0 auto;
+			max-height: 400px;
+			box-shadow: var(--image-shadow);
+			border-radius: 6px;
+		}
+
+		:global(.cover-image img) {
+			max-height: 400px;
+			object-fit: cover;
+		}
+
+		.content {
+			display: grid;
+			grid-template-columns:
+				1fr
+				min(var(--main-column-width), 100%)
+				1fr;
+
+			:global(> *) {
+				grid-column: 2;
+			}
+
+			:global(> .full-bleed) {
+				grid-column: 1 / 4;
+				width: 100%;
+				max-width: 1600px;
+				margin-left: auto;
+				margin-right: auto;
+			}
+		}
+
+		.tags {
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			gap: 5px;
+			flex-wrap: wrap;
+		}
+	}
+</style>
diff --git a/src/routes/v2/(blog-article)/benchmarking-the-torrust-bittorrent-tracker/+page.md b/src/routes/v2/(blog-article)/benchmarking-the-torrust-bittorrent-tracker/+page.md
new file mode 100644
index 0000000..a0ed524
--- /dev/null
+++ b/src/routes/v2/(blog-article)/benchmarking-the-torrust-bittorrent-tracker/+page.md
@@ -0,0 +1,621 @@
+---
+title: Benchmarking the Torrust BitTorrent Tracker
+slug: benchmarking-the-torrust-bittorrent-tracker
+coverImage: /images/posts/benchmarking-the-torrust-bittorrent-tracker/benchmarking-the-torrust-bittorrent-tracker-banner.webp
+date: 2024-03-19T00:00:00.000Z
+updated:
+excerpt: In the ever-evolving landscape of BitTorrent technology, performance and scalability are paramount. Torrust stands at the forefront, offering a suite of open-source software products designed to enhance peer-to-peer file sharing. At the heart of this suite is the Torrust BitTorrent Tracker, a Rust-based engine crafted for efficiency and speed. This post will introduce you to the benchmarking tools we are using at the moment for the tracker.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Performance
+  - Benchmarking
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Understating The Tracker](#understating-the-tracker)
+- [Benchmarking Methodology](#benchmarking-methodology)
+- [Internal Repository Benchmarking](#internal-repository-benchmarking)
+- [E2E UDP Benchmarking](#e2e-udp-benchmarking)
+- [Comparative UDP Benchmarking With Other Trackers](#comparative-udp-benchmarking-with-other-trackers)
+  - [Setup The Chihaya Tracker](#setup-the-chihaya-tracker)
+  - [Setup The Opentracker Tracker](#setup-the-opentracker-tracker)
+  - [Setup The Aquatic Tracker](#setup-the-aquatic-tracker)
+  - [Running The Bencher](#running-the-bencher)
+  - [Bencher Results](#bencher-results)
+- [Conclusion](#conclusion)
+- [Links](#links)
+
+</PostTable>
+
+<PostBody>
+
+## Introduction
+
+In the ever-evolving landscape of BitTorrent technology, performance and scalability are paramount. Torrust stands at the forefront, offering a suite of open-source software products designed to enhance peer-to-peer file sharing. At the heart of this suite is the [Torrust BitTorrent Tracker](https://github.com/torrust/torrust-tracker), a Rust-based engine crafted for efficiency and speed. This post will introduce you to the benchmarking tools we are using at the moment for the tracker. It will also shed light on its performance and how it stacks up against its contemporaries.
+
+Before going into details we should explain what are the tradeoffs we did on the design of the Torrust Tracker. Our goal is to design a robust, reliable and fast tracker but at the same time a feature-reach and sustainable one. Very often those two groups of objectives are exclusive. We know that being the fastest tracker implies some drawbacks. In general, our rule is:
+
+<Callout type="info">
+
+"Embracing a slight slowdown for substantial benefits underlines our commitment to delivering a tracker that's not just fast but also rich in features and usability."
+
+</Callout>
+
+We decided to use Rust due to its speed and memory-safe features but we also wanted to build a tracker with the following features:
+
+- A **comprehensive API** that allow users to perform any action or extract any data from the tracker.
+- A **good support for observability**. For example, a logging system that allow users to detect errors or extract statistics. The logging has several levels. Enabling more verbose logging affects performance. But if you are only interested in performance you can disable logging. Observability it's also related to testing. Code without support for observability it's usually hard to test too.
+- A **sustainable code**. Very often "fast code" means "direct code" without abstraction layers and separation of concerns, but that leads to code that is hard to maintain and eventually to a death project. It's hard to attract maintainers for open-source projects that are hard to understand. And even if it's not hard to understand it's usually hard to change because there are no independent parts that can be changed independently.
+
+## Understating The Tracker
+
+BitTorrent trackers play a crucial role in the file-sharing ecosystem, acting as intermediaries that facilitate the transfer of files among users. By tracking peer locations and helping them connect, these trackers ensure the swift and reliable distribution of data.
+
+Before benchmarking the tracker is important to know the internal architecture of the tracker. A deep dive into the Torrust Tracker's architecture reveals a four-layer design, crucial for benchmarking accuracy.
+
+The first layer is the delivery layer. Clients can connect to the tracker in different ways: using the HTTP tracker, the UDP tracker, the tracker API or console commands. Internally all requests are routed through application services and reaching the main tracker domain service that handles the `announce` and `scrape` requests. At the lowest level the tracker service stores all the information in different data structures. One of them is the torrent repository that holds the list of torrents. Each torrent entry on the list contains statistics like how many peers have downloaded the torrent and the list of peers for that torrent (swarm).
+
+<Image src="/images/posts/benchmarking-the-torrust-bittorrent-tracker/torrust-tracker-simplified-architecture.png" alt="Torrust Architecture" />
+
+## Benchmarking Methodology
+
+Our benchmarking approach encompasses three pivotal areas:
+
+- **Internal repository benchmarking**: Evaluating the repository within the tracker responsible for managing peer lists across torrents.
+- **End-to-End benchmarking**: Utilizing an external UDP tracker load test tool from the aquatic repository to simulate some real-world scenarios.
+- **Comparative Benchmarking with other trackers**: Employing the "Bencher" from the Aquatic GitHub repository to compare the Torrust Tracker against notable implementations like [opentracker](https://erdgeist.org/arts/software/opentracker/), [Chihaya](https://github.com/chihaya/chihaya), and [aquatic](https://github.com/greatest-ape/aquatic) itself.
+
+## Internal Repository Benchmarking
+
+Basically a tracker is just a shared data structure between all the BitTorrent peers. Peers announce themselves and the tracker builds up a list of torrents. For each torrent, the tracker keeps a list of peers interested in that torrent. The in-memory data structure is an array of structures that look like this one (example in JSON):
+
+<CodeBlock lang="json">
+
+```json
+{
+	"info_hash": "090c6d4fb3a03191c4ef1fda6236ef0efb2d5c10",
+	"seeders": 1,
+	"completed": 1,
+	"leechers": 0,
+	"peers": [
+		{
+			"peer_id": {
+				"id": "0x2d71423030303030303030303030303030303031",
+				"client": null
+			},
+			"peer_addr": "0.0.0.0:17548",
+			"updated": 1709916034742,
+			"updated_milliseconds_ago": 1709916034742,
+			"uploaded": 0,
+			"downloaded": 0,
+			"left": 0,
+			"event": "Completed"
+		}
+	]
+}
+```
+
+</CodeBlock>
+
+There are many ways to keep this information in memory. The access to this data is actually a bottleneck. Eventually all requests hit this structure. The problem is all `announce` requests need to update this structure. Due to Rust owning rules, only the owner can write into this struct. We have been trying different implementations to minimize contention. There is a trait for the torrent "Repository". You can benchmark the different repository implementations by running the following command:
+
+<CodeBlock lang="terminal">
+
+```terminal
+cargo run --release -p torrust-torrent-repository-benchmarks -- --threads 4 --sleep 0 --compare true
+```
+
+</CodeBlock>
+
+The output at the time of writing this post is:
+
+<CodeBlock lang="terminal">
+
+```terminal
+tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, Entry>>
+add_one_torrent: Avg/AdjAvg: (60ns, 59ns)
+update_one_torrent_in_parallel: Avg/AdjAvg: (10.909457ms, 0ns)
+add_multiple_torrents_in_parallel: Avg/AdjAvg: (13.88879ms, 0ns)
+update_multiple_torrents_in_parallel: Avg/AdjAvg: (7.772484ms, 7.782535ms)
+
+std::sync::RwLock<std::collections::BTreeMap<InfoHash, Entry>>
+add_one_torrent: Avg/AdjAvg: (43ns, 39ns)
+update_one_torrent_in_parallel: Avg/AdjAvg: (4.020937ms, 4.020937ms)
+add_multiple_torrents_in_parallel: Avg/AdjAvg: (5.896177ms, 5.768448ms)
+update_multiple_torrents_in_parallel: Avg/AdjAvg: (3.883823ms, 3.883823ms)
+
+std::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<std::sync::Mutex<Entry>>>>
+add_one_torrent: Avg/AdjAvg: (51ns, 49ns)
+update_one_torrent_in_parallel: Avg/AdjAvg: (3.252314ms, 3.149109ms)
+add_multiple_torrents_in_parallel: Avg/AdjAvg: (8.411094ms, 8.411094ms)
+update_multiple_torrents_in_parallel: Avg/AdjAvg: (4.106086ms, 4.106086ms)
+
+tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<std::sync::Mutex<Entry>>>>
+add_one_torrent: Avg/AdjAvg: (91ns, 90ns)
+update_one_torrent_in_parallel: Avg/AdjAvg: (3.542378ms, 3.435695ms)
+add_multiple_torrents_in_parallel: Avg/AdjAvg: (15.651172ms, 15.651172ms)
+update_multiple_torrents_in_parallel: Avg/AdjAvg: (4.368189ms, 4.257572ms)
+
+tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<tokio::sync::Mutex<Entry>>>>
+add_one_torrent: Avg/AdjAvg: (111ns, 109ns)
+update_one_torrent_in_parallel: Avg/AdjAvg: (6.590677ms, 6.808535ms)
+add_multiple_torrents_in_parallel: Avg/AdjAvg: (16.572217ms, 16.30488ms)
+update_multiple_torrents_in_parallel: Avg/AdjAvg: (4.073221ms, 4.000122ms)
+```
+
+</CodeBlock>
+
+We are benchmarking four scenarios that we think are the most relevant:
+
+- **Adding one torrent**: How long it takes to add a new torrent to the tracker when there is only one peer. We run it several times sequentially to calculate the average.
+- **Update one torrent in parallel**: This is the same as the previous one but running updates in parallel, meaning we spawn some threads to make the same request. This case tries to simulate the case where multiple peers try to announce the same torrent, so they are competing to write on the same repository entry, which contains the peer list.
+- **Add multiple torrents in parallel**: In this case, the same peer is adding different torrents at the same time. This case tries to simulate many peers announcing different torrents, so they are not conflicting to access the same peer list.
+- **Update multiple torrents in parallel**: Finally, this case is the same as the previous one, but we prefill the repository with all the torrents. This tries to simulate an scenario where multiple peers are announcing multiple torrents but the torrent entries already exists. The main different in this case is that the application might not need to allocate more memory to increase the data structure. So the problem is reduced to contention or locking (how many writes we can do in parallel on the same peer list).
+
+At the moment we are trying with other data structures that allow concurrent updates like [DashMap](https://docs.rs/dashmap/latest/dashmap/). See <https://github.com/torrust/torrust-tracker/issues/565>.
+
+## E2E UDP Benchmarking
+
+We have been using one of the aquatic packages to test the UDP tracker performance as a whole service.
+
+[Aquatic](https://github.com/greatest-ape/aquatic) is a high-performance open BitTorrent tracker including a lot a packages. One of the tools provided by Aquatic is a UDP load test command.
+
+In order to test the Torrust Tracker with the "UDP load test" tool you need to run both the tracker and this tester.
+
+### Running the Torrust Tracker
+
+You can follow the [Torrust Tracker documentation](https://docs.rs/torrust-tracker) to install the tracker but there is an especial configuration for benchmarking. First at all, you should build the tracker for release (`--release`) and you should also disable all services. Finally you should set the logging level to `error`.
+
+<Callout type="info">
+
+Logging levels are: `Off`, `Error`, `Warn`, `Info`, `Debug` and `Trace`. The more you increase the log level and the verbosity the worse the performance results are.
+
+</Callout>
+
+We provide a especial configuration for benchmarking `./share/default/config/tracker.udp.benchmarking.toml` with the best configuration to test the performance of the UDP tracker. After cloning the tracker repo you can build and run it with:
+
+<CodeBlock lang="terminal">
+
+```terminal
+cargo build --release
+TORRUST_TRACKER_PATH_CONFIG="./share/default/config/tracker.udp.benchmarking.toml" ./target/release/torrust-tracker
+```
+
+</CodeBlock>
+
+### Running The Aquatic UDP Load Test
+
+For updated instructions about how to setup the tool please follow the [official documentation](https://github.com/greatest-ape/aquatic/tree/master/crates/).
+
+<CodeBlock lang="terminal">
+
+```terminal
+cd /tmp
+git clone git@github.com:greatest-ape/aquatic.git
+cd aquatic
+cargo build --release -p aquatic_udp_load_test
+./target/release/aquatic_udp_load_test -p > "load-test-config.toml"
+```
+
+</CodeBlock>
+
+The last line `./target/release/aquatic_udp_load_test -p > "load-test-config.toml"` generates a config file. At least you will need to change the UDP port from `3000` to `6969` which is the default one in the Torrust Tracker. You can also edit other options like how many requests of each type you want to make.
+
+Edit the `load-test-config.toml`:
+
+<CodeBlock lang="terminal">
+
+```toml
+# ...
+server_address = "127.0.0.1:6969"
+# ...
+# Probability that a generated request is a connect request as part
+# of sum of the various weight arguments.
+weight_connect = 50
+# Probability that a generated request is a announce request, as part
+# of sum of the various weight arguments.
+weight_announce = 50
+# Probability that a generated request is a scrape request, as part
+# of sum of the various weight arguments.
+weight_scrape = 1
+# ...
+```
+
+</CodeBlock>
+
+Finally you can run the test with:
+
+<CodeBlock lang="toml">
+
+```toml
+./target/release/aquatic_udp_load_test -c "load-test-config.toml"
+```
+
+</CodeBlock>
+
+### Test Results
+
+Just as an example we show the test results with a non dedicated machine.
+
+**Machine used for the test**:
+
+- RAM: 64GiB
+- Processor: AMD Ryzen 9 7950X x 32
+- Graphics: AMD Radeon Graphics / Intel Arc A770 Graphics (DG2)
+- OS: Ubuntu 23.04
+- OS Type: 64-bit
+- Kernel Version: Linux 6.2.0-20-generic
+
+**Test result**:
+
+<CodeBlock lang="terminal">
+
+```terminal
+Requests out: 388702.94/second
+Responses in: 349832.25/second
+  - Connect responses:  173325.85
+  - Announce responses: 173061.13
+  - Scrape responses:   3445.27
+  - Error responses:    0.00
+Peers per announce response: 0.00
+Announce responses per info hash:
+  - p10: 1
+  - p25: 1
+  - p50: 1
+  - p75: 1
+  - p90: 2
+  - p95: 3
+  - p99: 106
+  - p99.9: 283
+  - p100: 357
+```
+
+</CodeBlock>
+
+## Comparative UDP Benchmarking With Other Trackers
+
+Aquatic also provides a tool to compare how several trackers perform on the same machine. At the moment they support these tracker:
+
+- [opentracker](https://erdgeist.org/arts/software/opentracker/).
+- [Chihaya](https://github.com/chihaya/chihaya).
+- [aquatic](https://github.com/greatest-ape/aquatic).
+
+We've opened a [PR](https://github.com/greatest-ape/aquatic/pull/191) to add support to the Torrust Tracker too.
+
+In order to run the Bencher you need to install all the trackers first.
+
+### Setup The Chihaya Tracker
+
+Follow the [official documentation](https://github.com/chihaya/chihaya). You will need to install Go:
+
+<CodeBlock lang="terminal">
+
+```terminal
+sudo apt install golang-go
+```
+
+</CodeBlock>
+
+### Setup The Opentracker Tracker
+
+You can `make` it from sources following the [official documentation](https://erdgeist.org/arts/software/opentracker/#toc-entry-3) or install it on Ubuntu with:
+
+<CodeBlock lang="terminal">
+
+```terminal
+cd /tmp
+cvs -d :pserver:cvs@cvs.fefe.de:/cvs -z9 co libowfat
+cd libowfat
+make
+cd ..
+git clone git://erdgeist.org/opentracker
+cd opentracker
+make
+cp opentracker ~/bin
+opentracker -h
+```
+
+</CodeBlock>
+
+<Callout type="info">
+
+NOTICE: Installing the opentracker from Ubuntu repositories did not work for us. Maybe arguments to run the application have changes in recent versions.
+
+</Callout>
+
+### Setup The Aquatic Tracker
+
+You can follow the [official documentation](https://github.com/greatest-ape/aquatic/tree/master/crates/udp). At the moment this is the process:
+
+<CodeBlock lang="terminal">
+
+```terminal
+sudo apt update && sudo apt upgrade -y
+sudo apt-get install libhwloc-dev
+cd /tmp
+git clone git@github.com:greatest-ape/aquatic.git
+cd aquatic
+cargo build --profile=release-debug --all-features -p aquatic_udp
+```
+
+</CodeBlock>
+
+<Callout type="info">
+
+NOTICE: `libhwloc-dev` is needed for `io-uring` feature.
+
+</Callout>
+
+### Running The Bencher
+
+You don't need to run the trackers manually the Bencher does it. First you need to build the Bencher:
+
+<CodeBlock lang="terminal">
+
+```terminal
+cd /tmp
+git clone git@github.com:greatest-ape/aquatic.git
+cd aquatic
+cargo build --profile=release-debug -p aquatic_bencher
+```
+
+</CodeBlock>
+
+And then you can run it with:
+
+<CodeBlock lang="terminal">
+
+```terminal
+./target/release-debug/aquatic_bencher udp
+```
+
+</CodeBlock>
+
+<Callout type="info">
+
+If you also want to include the Torrust Tracker make sure you use the fork in the [PR](https://github.com/greatest-ape/aquatic/pull/191).
+
+</Callout>
+
+### Bencher Results
+
+Again, this is only an example with the test result using a non dedicated machine.
+
+Machine used for the test:
+
+- RAM: 64GiB
+- Processor: AMD Ryzen 9 7950X x 32
+- Graphics: AMD Radeon Graphics / Intel Arc A770 Graphics (DG2)
+- OS: Ubuntu 23.04
+- OS Type: 64-bit
+- Kernel Version: Linux 6.2.0-20-generic
+
+Bencher result:
+
+<CodeBlock lang="terminal">
+
+```terminal
+# Benchmark report
+
+Total number of load test runs: 72
+Estimated duration: 0 hours, 44 minutes
+
+## Tracker cores: 1 (cpus: 0,16)
+### aquatic_udp run (socket workers: 1) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 351,834
+- Average tracker CPU utilization: 95.5%
+- Peak tracker RSS: 192.5 MiB
+### aquatic_udp run (socket workers: 1) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 372,991
+- Average tracker CPU utilization: 95.5%
+- Peak tracker RSS: 191.9 MiB
+### aquatic_udp (io_uring) run (socket workers: 1) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 389,576
+- Average tracker CPU utilization: 95.5%
+- Peak tracker RSS: 214 MiB
+### aquatic_udp (io_uring) run (socket workers: 1) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 409,824
+- Average tracker CPU utilization: 95.5%
+- Peak tracker RSS: 214.7 MiB
+### opentracker run (workers: 0) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 297,698
+- Average tracker CPU utilization: 95.5%
+- Peak tracker RSS: 71.7 MiB
+### opentracker run (workers: 0) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 307,874
+- Average tracker CPU utilization: 95.5%
+- Peak tracker RSS: 72 MiB
+### opentracker run (workers: 1) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 343,570
+- Average tracker CPU utilization: 95.4%
+- Peak tracker RSS: 72 MiB
+### opentracker run (workers: 1) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 378,880
+- Average tracker CPU utilization: 95.3%
+- Peak tracker RSS: 72.2 MiB
+### chihaya run () (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 115,159
+- Average tracker CPU utilization: 190%
+- Peak tracker RSS: 863.4 MiB
+### chihaya run () (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 113,002
+- Average tracker CPU utilization: 190%
+- Peak tracker RSS: 867.4 MiB
+### torrust-tracker run () (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 222,330
+- Average tracker CPU utilization: 189%
+- Peak tracker RSS: 193.3 MiB
+### torrust-tracker run () (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 216,407
+- Average tracker CPU utilization: 189%
+- Peak tracker RSS: 191.8 MiB
+## Tracker cores: 2 (cpus: 0-1,16-17)
+### aquatic_udp run (socket workers: 2) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 699,783
+- Average tracker CPU utilization: 191%
+- Peak tracker RSS: 195.6 MiB
+### aquatic_udp run (socket workers: 2) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 804,774
+- Average tracker CPU utilization: 191%
+- Peak tracker RSS: 193.9 MiB
+### aquatic_udp (io_uring) run (socket workers: 2) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 749,745
+- Average tracker CPU utilization: 190%
+- Peak tracker RSS: 237.4 MiB
+### aquatic_udp (io_uring) run (socket workers: 2) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 797,605
+- Average tracker CPU utilization: 190%
+- Peak tracker RSS: 239 MiB
+### opentracker run (workers: 2) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 692,167
+- Average tracker CPU utilization: 190%
+- Peak tracker RSS: 71.5 MiB
+### opentracker run (workers: 2) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 780,108
+- Average tracker CPU utilization: 190%
+- Peak tracker RSS: 72 MiB
+### chihaya run () (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 185,137
+- Average tracker CPU utilization: 371%
+- Peak tracker RSS: 8.2 GiB
+### chihaya run () (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 186,243
+- Average tracker CPU utilization: 380%
+- Peak tracker RSS: 7.1 GiB
+### torrust-tracker run () (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 415,864
+- Average tracker CPU utilization: 374%
+- Peak tracker RSS: 188.4 MiB
+### torrust-tracker run () (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 407,551
+- Average tracker CPU utilization: 375%
+- Peak tracker RSS: 188.9 MiB
+## Tracker cores: 4 (cpus: 0-3,16-19)
+### aquatic_udp run (socket workers: 4) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 1,270,832
+- Average tracker CPU utilization: 369%
+- Peak tracker RSS: 194.9 MiB
+### aquatic_udp run (socket workers: 4) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 1,482,250
+- Average tracker CPU utilization: 382%
+- Peak tracker RSS: 194.9 MiB
+### aquatic_udp (io_uring) run (socket workers: 4) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 1,217,457
+- Average tracker CPU utilization: 354%
+- Peak tracker RSS: 237.9 MiB
+### aquatic_udp (io_uring) run (socket workers: 4) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 1,618,228
+- Average tracker CPU utilization: 381%
+- Peak tracker RSS: 284.3 MiB
+### opentracker run (workers: 4) (load test workers: 8, cpus: 8-15,24-31)
+- Average responses per second: 1,348,825
+- Average tracker CPU utilization: 381%
+- Peak tracker RSS: 71.5 MiB
+### opentracker run (workers: 4) (load test workers: 12, cpus: 4-15,20-31)
+- Average responses per second: 1,546,907
+- Average tracker CPU utilization: 381%
+- Peak tracker RSS: 71 MiB
+### chihaya run () (load test workers: 8, cpus: 8-15,24-31)
+...
+```
+
+</CodeBlock>
+
+<Callout type="info">
+
+**IMPORTANT**: The test was run is a non dedicated machine running other tasks. It's just an example. You can get the latest results with dedicated machine on the [Aquatic](https://github.com/greatest-ape/aquatic) repo.
+
+</Callout>
+
+The extracted and ordered results for 1 core are:
+
+Average responses per second with 8 load test workers and cpus: 8-15,24-31
+
+1. **389,576** aquatic (io_uring)
+2. **351,834** aquatic
+3. **343,570** opentracker (workers 1)
+4. **297,698** opentracker (workers 0)
+5. **222,330** torrust-tracker
+6. **115,159** chihaya
+
+Average responses per second with 12 load test workers and cpus: 4-15,20-31
+
+1. **409,824** aquatic (io_uring)
+2. **378,880** opentracker (workers 1)
+3. **372,991** aquatic
+4. **307,874** opentracker (workers 0)
+5. **216,407** torrust-tracker
+6. **113,002** chihaya
+
+The [latest official results](https://github.com/greatest-ape/aquatic/blob/master/documents/aquatic-udp-load-test-2024-02-10.md) (2024-02-10):
+
+<Image src="/images/posts/benchmarking-the-torrust-bittorrent-tracker/aquatic-bencher-average-responses-per-second.png" alt="Torrust Architecture" />
+
+<Callout type="info">
+
+The Aquatic "Bencher" uses the Aquatic "UDP load test".
+
+</Callout>
+
+## Conclusion
+
+As you have seen we are collecting metrics to improve the tracker and avoid performance regressions, by using these benchmarking tools provided by Aquatic. Although performance is important there are other factor like horizontal scalability that are even more critical because sooner or later no matter how powerful is your machine it will be not enough the handle all the requests. But that is our of the scope of this article.
+
+On the other hand, we have analyzed performance only from the point of view of number of request handled per second. Memory consumption should be also considered. We have started instrumenting the application to track memory consumption. See <https://github.com/torrust/torrust-tracker/issues/567>.
+
+If you see something wrong or you want to contribute by:
+
+- Adding new sections.
+- Fixing typos.
+- Making it clearer.
+- Adding links.
+- Or whatever you think that could be interesting to have,
+
+please open an [issue](https://github.com/torrust/torrust-website/issues) or a [PR](https://github.com/torrust/torrust-website/pulls).
+
+If you have any questions or issues please open an issue in the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index: <https://github.com/torrust/torrust-index/issues>
+- Torrust Website: <https://github.com/torrust/torrust-index-gui/issues>
+- Torrust Compose: <https://github.com/torrust/torrust-compose>
+- Containerizing Rust Applications Examples: <https://github.com/torrust/containerizing-rust-apps-examples>
+
+We very welcome any contributions to the projects or [this article](https://github.com/torrust/torrust-website/issues).
+
+## Links
+
+Other trackers:
+
+- [Chihaya](https://github.com/chihaya/chihaya).
+- [opentracker](https://erdgeist.org/arts/software/opentracker/).
+- [aquatic](https://github.com/greatest-ape/aquatic).
+
+Crates for concurrent writes:
+
+- [DashMap](https://docs.rs/dashmap/latest/dashmap/).
+
+Other links:
+
+- [Torrust Tracker Benchmarking Docs](https://github.com/torrust/torrust-tracker/blob/develop/docs/benchmarking.md).
+- [Aquatic UDP load test tool](https://github.com/greatest-ape/aquatic/tree/master/crates/udp_load_test).
+- [Aquatic Bencher](https://github.com/greatest-ape/aquatic/tree/master/crates/bencher).
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/containerizing-rust-applications-best-practices/+page.md b/src/routes/v2/(blog-article)/containerizing-rust-applications-best-practices/+page.md
new file mode 100644
index 0000000..fda5a33
--- /dev/null
+++ b/src/routes/v2/(blog-article)/containerizing-rust-applications-best-practices/+page.md
@@ -0,0 +1,1064 @@
+---
+title: Containerizing Rust Applications
+slug: containerizing-rust-applications-best-practices
+coverImage: /images/posts/rust-crab-carrying-a-shipping-container.jpeg
+date: 2023-11-09T12:08:04.295Z
+updated:
+excerpt: Torrust services (Tracker and Index) support docker, we want to ensure that contributors understand our containerfile and we also want to share good practices for containerizing Rust applications.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Documentation
+  - Docker
+  - Containers
+  - Rust
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Requirements](#requirements)
+- [We Use Docker (OCI) Containers](#we-use-docker-oci-containers)
+- [Basic Dockerized Rust Application](#basic-dockerized-rust-application)
+- [Use Multi-Stage Builds to Minimize the Image Size](#use-multi-stage-builds-to-minimize-the-image-size)
+- [Image Variants](#image-variants)
+- [Introduction to Docker Layers Cache](#introduction-to-docker-layers-cache)
+- [Caching Cargo Dependencies](#caching-cargo-dependencies)
+  - [Demonstration of Caching Cargo Dependencies Using a Custom Solution](#demonstration-of-caching-cargo-dependencies-using-a-custom-solution)
+  - [Caching Cargo Dependencies With Cargo Chef](#caching-cargo-dependencies-with-cargo-chef)
+- [Installing Rust Binaries With Cargo Binstall](#installing-rust-binaries-with-cargo-binstall)
+- [Archiving And Reusing Builds With Cargo Nextest](#archiving-and-reusing-builds-with-cargo-nextest)
+- [Running Container Without Sudo](#running-container-without-sudo)
+  - [Use The `docker run --user` Argument](#use-the-docker-run---user-argument)
+  - [Create The User At Runtime](#create-the-user-at-runtime)
+- [Decomposing the Torrust Tracker Containerfile](#decomposing-the-torrust-tracker-containerfile)
+- [Other Good Practices](#other-good-practices)
+- [Other Considerations](#other-considerations)
+- [Links](#links)
+- [Conclusion](#conclusion)
+
+</PostTable>
+
+<PostBody>
+
+## Introduction
+
+BitTorrent, an age-old protocol, is a powerful way to share data over the internet.
+In our journey to building robust BitTorrent projects, we've chosen the Rust
+programming language for its memory safety and concurrency features. To streamline
+the development and distribution of our projects, we've also employed Docker and
+Podman.
+
+In this post, we'll dive deep into the best practices we've adopted for
+dockerizing our Rust applications.
+
+Our [Containerfiles](https://docs.docker.com/engine/reference/builder/), _commonly called a `"Dockerfile"`_, are stored in the roots of our two main rust repositories, for reference:
+
+- Torrust-Tracker [Containerfile](https://github.com/torrust/torrust-tracker/blob/develop/Containerfile).
+- Torrust-Index [Containerfile](https://github.com/torrust/torrust-index/blob/develop/Containerfile).
+
+### Example
+
+All of the examples included in this blog post are publicly available in our "[Containerizing Rust Apps Examples](https://github.com/torrust/containerizing-rust-apps-examples)"
+GitHub Repository.
+
+> **_Please Note:_** The actual `Containerfile` for the **Tracker** and **Index** services builds images for
+> both `debug` and `release` modes. For learning purposes we are using a simplified
+> version here which only builds the `release` mode:
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+# Extracted example of our Containerfile.
+
+## Base Builder Image
+FROM rust:bookworm as chef
+WORKDIR /tmp
+RUN curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
+RUN cargo binstall --no-confirm cargo-chef cargo-nextest
+
+## Tester Image
+FROM rust:slim-bookworm as tester
+WORKDIR /tmp
+RUN apt-get update; apt-get install -y curl; apt-get autoclean
+RUN curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
+RUN cargo binstall --no-confirm cargo-nextest
+
+## Su Exe Compile
+FROM docker.io/library/gcc:bookworm as gcc
+COPY ./contrib/dev-tools/su-exec/ /usr/local/src/su-exec/
+RUN cc -Wall -Werror -g /usr/local/src/su-exec/su-exec.c -o /usr/local/bin/su-exec; chmod +x /usr/local/bin/su-exec
+
+## Chef Prepare (look at project and see wat we need)
+FROM chef AS recipe
+WORKDIR /build/src
+COPY . /build/src
+RUN cargo chef prepare --recipe-path /build/recipe.json
+
+## Cook (release)
+FROM chef AS dependencies
+WORKDIR /build/src
+COPY --from=recipe /build/recipe.json /build/recipe.json
+RUN cargo chef cook --tests --benches --examples --workspace --all-targets --all-features --recipe-path /build/recipe.json --release
+RUN cargo nextest archive --tests --benches --examples --workspace --all-targets --all-features --archive-file /build/temp.tar.zst --release  ; rm -f /build/temp.tar.zst
+
+## Build Archive (release)
+FROM dependencies AS build
+WORKDIR /build/src
+COPY . /build/src
+RUN cargo nextest archive --tests --benches --examples --workspace --all-targets --all-features --archive-file /build/full-example.tar.zst --release
+
+# Extract and Test (release)
+FROM tester as test
+WORKDIR /test
+COPY . /test/src
+COPY --from=build \
+  /build/full-example.tar.zst \
+  /test/full-example.tar.zst
+RUN cargo nextest run --workspace-remap /test/src/ --extract-to /test/src/ --no-run --archive-file /test/full-example.tar.zst
+RUN cargo nextest run --workspace-remap /test/src/ --target-dir-remap /test/src/target/ --cargo-metadata /test/src/target/nextest/cargo-metadata.json --binaries-metadata /test/src/target/nextest/binaries-metadata.json
+
+RUN mkdir -p /app/bin/; cp -l /test/src/target/release/full-example /app/bin/full-example
+RUN chown -R root:root /app; chmod -R u=rw,go=r,a+X /app; chmod -R a+x /app/bin
+
+## Runtime
+FROM gcr.io/distroless/cc-debian12:debug as runtime
+RUN ["/busybox/cp", "-sp", "/busybox/sh","/busybox/cat","/busybox/ls","/busybox/env", "/bin/"]
+COPY --from=gcc --chmod=0555 /usr/local/bin/su-exec /bin/su-exec
+ARG USER_ID=1000
+COPY --chmod=0555 ./share/container/entry_script_sh /usr/local/bin/entry.sh
+ENTRYPOINT ["/usr/local/bin/entry.sh"]
+
+## Release Runtime
+FROM runtime as release
+COPY --from=test /app/ /usr/
+CMD ["/usr/bin/full-example"]
+```
+
+</CodeBlock>
+
+The real version in production contains some duplicate stages to build the `debug`
+mode. Those stages are almost identical to the ones in this example and are therefore omitted. Only some flags and names change.
+
+Don't be scared of the example, next we will go through all the lines and explain what
+they do, but before doing that, we will explain some basic concepts and the patterns
+applied one by one.
+
+## Requirements
+
+In order to run some of the examples in this article you will need to install:
+
+- [Docker version 24.0.6, build ed223bc](https://docs.docker.com/get-docker/)
+
+## We Use Docker (OCI) Containers
+
+The standardized [Open Container Initiative (OCI)](https://opencontainers.org/) allows Torrust the possibility of reliable and cross-platform distribution and deployment of our Software.
+
+This allows for administrators who may be interested in our software to quickly and easily test-out our software and see if it suits their needs. It also allows administrators to more easily deploy our software, as most of the web-hosting systems have great support for OCI Containers.
+
+In addition, our End-to-End testing infrastructure is made easier by using a [docker-compose](https://docs.docker.com/compose/) configuration, that is taking advantage of our docker containers.
+
+## Basic Dockerized Rust Application
+
+The simplest Dockerfile for a Rust application is as follows:
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+# We start from full base defacto Debian image
+FROM rust:latest
+WORKDIR /app
+RUN cargo init
+RUN cargo build --release
+CMD ["./target/release/app"]
+```
+
+</CodeBlock>
+
+And you can build the image and run it with:
+
+<CodeBlock lang="console">
+
+```console
+docker build -t docker-rust-app-basic .
+docker run --rm -it docker-rust-app-basic
+
+Hello, world!
+```
+
+</CodeBlock>
+
+That creates a docker image which is **1.39 GB**!.
+
+<CodeBlock lang="console">
+
+```console
+$ docker image ls | grep docker-rust-app-basic
+docker-rust-app-basic                            latest          7294f20bb52c   2 minutes ago   1.39GB
+```
+
+</CodeBlock>
+
+We are going to see how to improve
+that and other things like common patters, good practices and other considerations.
+
+## Use Multi-Stage Builds to Minimize the Image Size
+
+A common pattern to build smaller docker images is to use multi-stage Dockerfiles.
+
+You can compile your application with all of the Rust tooling and then use the
+final binary in a slim operating system. This image does not contain the common
+packages contained in the default tag and only contains the minimal packages
+needed to run your compiled Rust application.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+# This is the first stage. This image is used to compile the Rust application.
+FROM rust:bookworm as builder
+WORKDIR /app
+RUN cargo init
+# Install the package in the current directory
+RUN cargo install --path .
+CMD ["./target/release/app"]
+
+# This is the production stage.
+# The slim image does not contain the common packages contained in the default tag and only contains the minimal packages needed to run rust.
+FROM debian:bookworm-slim
+COPY --from=builder /usr/local/cargo/bin/app /usr/local/bin/app
+CMD ["app"]
+```
+
+</CodeBlock>
+
+The example is very easy and you can build and run the image with:
+
+<CodeBlock lang="console">
+
+```console
+docker build -t docker-rust-app-multi-stage .
+docker run --rm -it docker-rust-app-multi-stage
+Hello, world!
+$ docker image ls | grep docker-rust-app-multi-stage
+docker-rust-app-multi-stage                             latest          bc3ae797b55e   11 seconds ago   84.7MB
+```
+
+</CodeBlock>
+
+As you can see this new image is only 84.7MB. That's a huge improvement!
+
+## Image Variants
+
+As you can see in our `Containerfile`, the images we are using are the following:
+
+### rust:bookworm
+
+```Dockerfile
+FROM rust:bookworm
+```
+
+At the time of writing this article the latest release is [Debian 12.2](https://www.debian.org/releases/bookworm/).
+It is also (currently) known as stable or by its codename "Bookworm". You will
+see that we use that one because it is the latest one.
+
+### rust:slim-bookworm
+
+```Dockerfile
+FROM rust:slim-bookworm
+```
+
+Images with the `slim` suffix do not contain the common packages contained in the
+default tag and only contain the minimal packages needed to run rust. We are using
+it for the "tester" stage.
+
+### gcc:bookworm
+
+```Dockerfile
+FROM docker.io/library/gcc:bookworm
+```
+
+The GCC image is used to compile an small C program which is a simple tool that
+just executes a program with different privileges. When we start the container
+we run it with a USER ID passed by an environment variable and not with `root`
+privileges.
+
+### cc-debian12:debug
+
+```Dockerfile
+FROM gcr.io/gcr.io/distroless/cc-debian12:debug
+```
+
+And finally a "Distroless" container image is used for runtime. [Why should you use distroless images?](https://github.com/GoogleContainerTools/distroless#why-should-i-use-distroless-images).
+
+- They are small.
+- They only have what you need to run your app.
+- They reduce the risk of vulnerabilities.
+
+<Callout type="info">
+
+We use the `:debug` variant of the distroless cc, as it includes the busybox binary,
+giving us a shell that is needed to run the entry-script. We will explain this later.
+
+</Callout>
+
+## Introduction To Docker Layers Cache
+
+Caching is a pivotal aspect of optimizing Docker builds, especially with Rust projects. Proper caching ensures faster builds, as unchanged dependencies don't have to be recompiled. By leveraging Docker's layer caching mechanism, we can effectively cache Rust dependencies and speed up our Docker builds.
+
+Docker uses a layered filesystem to store images. Each layer is a set of changes to the filesystem. When you create a new container, you add a new writable layer on top of the underlying layers. This layer is often called the "container layer". All changes made to the running container, such as writing new files, modifying existing files, and deleting files, are written to this thin writable container layer.
+
+## Caching cargo dependencies
+
+A common pattern used in all languages is to separate the dependencies installation from the application build. This is done to take advantage of the Docker layer caching mechanism. The dependencies installation is done in a separate layer, and the application build is done in a separate layer. This way, if the application code changes, the dependencies installation layer is not rebuilt, and only the application build layer is rebuilt.
+
+This improves build times because dependencies installation is usually a time-consuming process and it is something you normally do not change often. The application build, on the other hand, is something you change often, and it is usually a quick process.
+
+Docker build is executed in the order that you define instructions so you put things that change less frequently at the beginning of the Dockerfile and things that change more frequently at the end of the Dockerfile.
+
+There are two levels of dependencies:
+
+- System dependencies. For instance `SQLite`, `curl` and other libraries your application depends on.
+- Rust dependencies. These are the Rust packages that you want to install using cargo. Rust packages are called `crates` and you can find them on <https://crates.io/>
+
+### Demonstration of Caching Cargo Dependencies Using a Custom Solution
+
+First we demonstrate how cargo dependencies caching works but showing a custom solution:
+
+We first create an **empty application configuration** which uses the same dependencies.
+We build the application, downloading and building all the dependencies and creating a docker cache layer.
+
+Then we build the application. With these layers yo do not need to re-build the dependencies
+when you change the application code.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+FROM rust:latest as builder
+
+WORKDIR /app
+
+# Copy over the manifest files
+COPY Cargo.toml Cargo.lock /app/
+
+# Create a dummy main.rs to build dependencies
+RUN mkdir src && echo "fn main() { println!(\"if you see this, the build broke\"); }" > src/main.rs
+
+# This build step will cache the dependencies as they're not changed
+RUN cargo build --release
+
+# Now, remove the dummy main.rs and copy your source code
+COPY . /app
+
+# You'll need to update the last modified of the main.rs file to inform cargo to rebuild it
+RUN touch -a -m ./src/main.rs
+
+# Build the application for release. Since dependencies are cached, this will only build your code
+RUN cargo build --release
+
+CMD ["./target/release/custom-dependencies-cache"]
+```
+
+</CodeBlock>
+
+Instead of this custom solution, we use and recommend [cargo chef](https://github.com/LukeMathWalker/cargo-chef) which is a cargo-subcommand that specializes in speeding up Rust Docker builds using Docker layer caching.
+
+### Caching Cargo Dependencies With Cargo Chef
+
+In this example, we show how to use [cargo chef](https://github.com/LukeMathWalker/cargo-chef), that we prefer to use.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+FROM rust:latest as chef
+
+WORKDIR /app
+
+# Install cargo-chef
+RUN cargo install cargo-chef --locked
+
+# Examines your project and builds a recipe that captures the set of information required to build your dependencies
+FROM chef AS planner
+
+COPY . .
+
+RUN cargo chef prepare --recipe-path recipe.json
+
+FROM chef AS builder
+
+COPY --from=planner /app/recipe.json recipe.json
+
+# Build dependencies - this is the caching Docker layer!
+RUN cargo chef cook --release --recipe-path recipe.json
+
+COPY . .
+
+# Build the application for release. Since dependencies are cached, this will only build your code
+RUN cargo build --release
+
+CMD ["./target/release/dependencies-cache-with-cargo-chef"]
+```
+
+</CodeBlock>
+
+While it does more or less the same as the custom solution. It caches dependencies in a separate layer and has some other [benefits](https://github.com/LukeMathWalker/cargo-chef#benefits-of-cargo-chef).
+
+## Installing Rust Binaries With Cargo Binstall
+
+`cargo binstall` is a cargo subcommand that allows installing Rust binaries as an alternative to building from source (via cargo install) or manually downloading packages.
+
+Cargo Binstall repo: <https://github.com/cargo-bins/cargo-binstall>.
+
+We are using it to install `cargo chef` and `cargo nextest` packages easily.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+
+FROM rust:latest
+WORKDIR /app
+# Install `cargo binstall`
+RUN curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
+# Install Rust binaries with `cargo binstall`
+RUN cargo binstall --no-confirm cargo-chef cargo-nextest
+RUN cargo chef --version && cargo nextest --version
+RUN cargo init
+RUN cargo build --release
+CMD ["./target/release/app"]
+
+```
+
+</CodeBlock>
+
+## Archiving And Reusing Builds With Cargo Nextest
+
+[cargo-nextest](https://nexte.st/) is a Rust test runner.
+
+It has a subcommand `cargo nextest archive` that can archive builds artifacts.
+This is useful to separate the "build" phase from the "run" phase.
+
+In the [official documentation](https://nexte.st/book/reusing-builds.html) they
+describe some use cases like:
+
+- **Cross-compilation**. The build machine has a different architecture, or runs a different operating system, from the target machine.
+- **Test partitioning**. Build once on the build machine, then partition test execution across multiple target machines.
+- **Saving execution time** on more valuable machines. For example, build tests on a regular machine, then run them on a machine with a GPU attached to it.
+
+We are using it for two reasons:
+
+- **Test partitioning**. We build the application in a docker stage and then run
+  the tests in another stage. This way we can separate the build and test phases.
+- **Passing the binary to the next stage**. After building the application we archive
+  the build artifacts and then we extract them in the next stage to run the tests.
+  Finally we copy the binary to the final "runtime" stage.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## First stage to install the nextest tool
+FROM rust:latest as nextest
+RUN cargo install cargo-nextest --locked
+
+## Second stage to build the application and package it with nextest
+FROM nextest AS builder
+WORKDIR /build/src
+COPY . /build/src
+RUN cargo build
+# We archive the build artifacts to reuse them in the next stage
+# NOTICE: the application must contains at least one integration test in order
+# include the binary in the archive.
+# See: https://github.com/nextest-rs/nextest/issues/423
+RUN cargo nextest archive --tests --benches --examples --workspace --all-targets --all-features --archive-file /build/archiving-and-reusing-builds.tar.zst
+CMD ["/build/src/target/debug/archiving-and-reusing-builds"]
+
+## Third stage to test the application
+FROM nextest AS tester
+WORKDIR /test
+COPY . /test/src/
+COPY --from=builder \
+    /build/archiving-and-reusing-builds.tar.zst \
+    /test/archiving-and-reusing-builds.tar.zst
+# We extract the build artifacts from the archive
+RUN cargo nextest run --workspace-remap /test/src/ --extract-to /test/src/ --no-run --archive-file /test/archiving-and-reusing-builds.tar.zst
+# We run the tests. We override the default target-dir to use the application binary,
+# otherwise it would be created in a temporary directory and we wouldn't be able to
+# copy it in the next stage.
+RUN cargo nextest run --workspace-remap /test/src/ --target-dir-remap /test/src/target/ --cargo-metadata /test/src/target/nextest/cargo-metadata.json --binaries-metadata /test/src/target/nextest/binaries-metadata.json
+RUN mkdir -p /app/bin/; cp -l /test/src/target/debug/archiving-and-reusing-builds /app/bin/archiving-and-reusing-builds
+CMD ["/app/bin/archiving-and-reusing-builds"]
+
+## Fourth stage to run the application in production
+FROM nextest AS runtime
+WORKDIR /app
+# We take the application binary from the tester stage to ensure the binary we
+# use has passed the tests.
+COPY --from=tester /app/bin/archiving-and-reusing-builds /app/
+CMD ["/app/archiving-and-reusing-builds"]
+```
+
+</CodeBlock>
+
+<Callout type="info">
+
+**NOTICE**: The application must contain at least one integration test in order
+include the binary in the archive. See this [issue](https://github.com/nextest-rs/nextest/issues/423)
+for more info.
+
+</Callout>
+
+## Running Container Without Sudo
+
+By default docker is installed and runs containers as `root`. If you build this image:
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+FROM rust:latest
+WORKDIR /app
+RUN cargo init
+RUN cargo build --release
+CMD ["./target/release/app"]
+```
+
+</CodeBlock>
+
+And you run it with the following command:
+
+<CodeBlock lang="console">
+
+```console
+docker build -t docker-rust-app-running-with-root .
+docker run --rm -it docker-rust-app-running-with-root whoami
+```
+
+</CodeBlock>
+
+You will see it is executed as `root`.
+
+You should not execute containers as `root` because of:
+
+1. **The Principle of Least Privilege**: This is a security concept that encourages the minimal user permission level necessary to perform a task. Running containers as root goes against this principle because if a process inside the container can run with root privileges, it can execute any command inside the container, which could be dangerous if the container gets compromised.
+
+2. **Host System Vulnerability**: Containers are designed to be isolated from the host system. However, there are ways that a container could potentially interact with the host, particularly if there are misconfigurations or vulnerabilities in the container runtime or the host's kernel. A container running as root might be able to exploit such vulnerabilities to gain control over the host system.
+
+3. **Immutable Infrastructure**: Containers are often used as part of an immutable infrastructure, where container images are pre-built and should not change. Running as root makes it easier to make changes to the running container, which can lead to "configuration drift" and unexpected behavior.
+
+4. **Accidental Damage**: Even if an attacker does not compromise the container, running as root increases the risk of accidental damage by the container's own applications or administrators. For example, a poorly crafted command could delete critical files or disrupt important processes.
+
+There are some ways to avoid running the container as `root`. We will see all of them.
+
+### Use the `USER` instruction
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+FROM rust:latest
+
+WORKDIR /app
+
+RUN cargo init
+RUN cargo build --release
+
+USER www-data
+
+CMD ["./target/release/app"]
+```
+
+</CodeBlock>
+
+You can add the `USER` instruction before the last command. In that example we
+know that the base image already contains the user `www-data`.
+
+<CodeBlock lang="console">
+
+```console
+docker run --rm -it docker-rust-app-running-with-root cat /etc/passwd | grep www-data
+www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
+```
+
+</CodeBlock>
+
+But you can also create a specific user for your application:
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+FROM rust:latest
+
+WORKDIR /app
+
+RUN cargo init
+RUN cargo build --release
+
+RUN groupadd -r appuser
+RUN useradd -r -u 1001 -g appuser appuser
+
+USER appuser
+
+CMD ["./target/release/app"]
+```
+
+</CodeBlock>
+
+Using the `USER` instruction is considered a good practice because by default the container
+will not run as root. In that example, docker will run the container as the user with the ID `1001`.
+
+<Callout type="info">
+
+The Linux Standard Base Core Specification defines three different ranges for
+user IDs, the value from 0 to 99, 100 to 999, and 1000 and above. The first two
+ranges are reserved for system users. All the regular users start from 1000.
+It's also important to note that the user ID 0 is reserved for the root user and
+Linux kernel uses the user id and group id to handle the permissions. The host
+machine and the docker container might have the same user ID but different usernames.
+
+</Callout>
+
+If you run that container, `appuser` will have the same permissions as the user `1001`
+in the host system, whatever it is the name of that user in the host machine.
+
+### Use The `docker run --user` Argument
+
+You can also overwrite the user running the container with the argument `--user`:
+
+<CodeBlock lang="console">
+
+```console
+docker run --user www-data --rm -it docker-rust-app-running-with-root whoami
+www-data
+```
+
+</CodeBlock>
+
+In this example, even though the image is executed as root by default, it will be
+executed as the `www-data` user.
+
+Notice you can even use a non-existing user in both the host and the docker image.
+
+<CodeBlock lang="console">
+
+```console
+$ docker run --user 1001 --rm -it docker-rust-app-running-with-root bash
+I have no name!@895b0f6a3dbb:/app$
+```
+
+</CodeBlock>
+
+All these solutions work but they all have a drawback: you need to know the user
+ID at build time (when you build the docker image). You usually want to run the
+container in different environments and sometimes you want to use a different
+user ID for each environment. For example:
+
+- **For development**: If you are using Ubuntu, your user ID is probably `1000`. When
+  you run the container locally you want to run it using that ID, so that you don't
+  have any problems with permissions.
+- **For CI**: The servers you are using for continuous integration (for instance, GitHub runners)
+  might use an specif user. You could use some cache folders and maybe you need to
+  use the same user ID as the CI server.
+- **For production**: You could create a specific user for your application and use that
+  user ID.
+
+With the proposed solutions you would need to rebuild the docker image so that the
+user ID inside the container is the same as the host user ID.
+
+### Create The User At Runtime
+
+There is al alternative to the previous solutions that makes it possible to **run the
+container with different user IDs without rebuilding the image**.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+
+## Compile su-exec
+FROM docker.io/library/gcc:bookworm as gcc
+COPY ./contrib/dev-tools/su-exec/ /usr/local/src/su-exec/
+RUN cc -Wall -Werror -g /usr/local/src/su-exec/su-exec.c -o /usr/local/bin/su-exec; chmod +x /usr/local/bin/su-exec
+
+## Application
+FROM rust:bookworm as builder
+WORKDIR /app
+RUN cargo init
+RUN cargo build --release
+CMD ["./target/release/app"]
+
+## Runtime
+FROM gcr.io/distroless/cc-debian12:debug as runtime
+RUN ["/busybox/cp", "-sp", "/busybox/sh","/busybox/cat","/busybox/ls","/busybox/env", "/bin/"]
+
+COPY --from=builder /app/target/release/app /usr/local/bin/app
+COPY --from=gcc --chmod=0555 /usr/local/bin/su-exec /bin/su-exec
+COPY --chmod=0555 ./share/container/entry_script_sh /usr/local/bin/entry.sh
+
+ENTRYPOINT ["/usr/local/bin/entry.sh"]
+CMD ["/usr/local/bin/app"]
+
+```
+
+</CodeBlock>
+
+This is the approach we use in Torrust. You run the docker as `root` but we always
+use an entrypoint. That entrypoint creates a new user with an ID provided as an
+environment variable.
+
+The `entry.sh` script is always called when you run the container because it is
+defined as an `ENTRYPOINT`. This "middleware" script creates the user if it does
+not exist, and then runs the application using the [su-exec](https://github.com/ncopa/su-exec)
+program to change the user ID it is executed with.
+
+**For those who are interested here is our: [entry script](https://github.com/torrust/torrust-tracker/blob/develop/share/container/entry_script_sh).**
+
+As you can read on the su-exec documentation:
+
+<Callout type="info">
+
+"su-exec" is a simple tool that will simply execute a program with different privileges.
+The program will be executed directly and not run as a child, like su and sudo does,
+which avoids TTY and signal issues (see below).
+
+Notice that su-exec depends on being run by the root user, non-root users do not
+have permission to change uid/gid.
+
+</Callout>
+
+The advantage of this approach is that you don't have to worry about the user ID
+when you build the docker image. You can run the container as root and then use
+the entrypoint to create the user and run the application with that user.
+
+The entrypoint also ensures that the application is executed with the correct
+permissions. You cannot run the application as root unless you explicitly set
+the environment variable `USER_ID` to `0`.
+
+If you want to contribute to Torrust we think that we could simplify the Containerfile
+if the "su-exec" command were available in Rust. Because we could reuse one of the
+Rust docker images we are using for other docker stages.
+
+## Decomposing the Torrust Tracker Containerfile
+
+Finally we can explain line by line what the [Torrust Tracker Containerfile](https://github.com/torrust/torrust-tracker/blob/develop/Containerfile) does.
+
+Rust apps can be built in `debug` or `release` mode. The `Containerfile` builds both
+modes and then it runs the tests for both modes. We have removed the `debug` mode
+to keep the example short. But it is almost the same code. For the `release` mode
+the flag `--release` is added to some commands.
+
+We can abstract away the stages:
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Base Builder Image
+FROM rust:bookworm as chef
+# Install tools needed to build the application: cargo-chef cargo-nextest
+
+## Tester Image
+FROM rust:slim-bookworm as tester
+# Install tools needed to test the application: cargo-nextest
+
+## Su Exe Compile
+FROM docker.io/library/gcc:bookworm as gcc
+# Compile the su-exec program which is used at runtime to change the user running the container.
+
+## Chef Prepare (look at project and see wat we need)
+FROM chef AS recipe
+# Prepare the info needed to build and cache cargo dependencies
+
+## Cook (release)
+FROM chef AS dependencies
+# Re-hydrate the minimum project skeleton identified by `cargo chef prepare` and build it to cache dependencies
+
+## Build Archive (release)
+FROM dependencies AS build
+# build and archive the application
+
+# Extract and Test (release)
+FROM tester as test
+# Extract the application from the archived artifacts and run the tests.
+# And copy the binary to an specified location so it can be used in the `release`
+# stage.
+
+## Runtime
+FROM gcr.io/distroless/cc-debian12:debug as runtime
+# Minimal image to run the app in production.
+# Includes the entrypoint to setup and run the application with a different user Id.
+
+## Release Runtime
+FROM runtime as release
+# Runtime for release mode. It copies the binary from the `test` stage and runs it
+# via the entrypoint added in the `runtime` stage.
+```
+
+</CodeBlock>
+
+Let's see each stage individually.
+
+First, we have a base builder image where we install basic tools to build the application.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Base Builder Image
+FROM rust:bookworm as chef
+WORKDIR /tmp
+RUN curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
+RUN cargo binstall --no-confirm cargo-chef cargo-nextest
+```
+
+</CodeBlock>
+
+There is nothing really strange here. We use the latest Debian “bookworm” at the time
+of writing this article. And we also use `binstall` to install the binaries, since
+both of these binaries are written in Rust.
+
+The next stage is the base Tester Image. It only installs `cargo-nextest` to run the tests.
+We also use the Debian “bookworm” but the `slim` variant, since we don't need too much
+to only run the tests.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Base Tester Image
+FROM rust:slim-bookworm as tester
+WORKDIR /tmp
+RUN apt-get update; apt-get install -y curl; apt-get autoclean
+RUN curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
+RUN cargo binstall --no-confirm cargo-nextest
+```
+
+</CodeBlock>
+
+The following is another stage used just to compile the small program [su-exec](https://github.com/ncopa/su-exec) that we use to change the user ID when we run the container. The program is written
+in C code, so we only need a C compiler.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Su Exe Compile
+FROM docker.io/library/gcc:bookworm as gcc
+COPY ./contrib/dev-tools/su-exec/ /usr/local/src/su-exec/
+RUN cc -Wall -Werror -g /usr/local/src/su-exec/su-exec.c -o /usr/local/bin/su-exec; chmod +x /usr/local/bin/su-exec
+```
+
+</CodeBlock>
+
+From this point, we start building the application. First, we build the dependencies
+and we cache them into an independent stage.
+
+The first stage is only to "build the recipe" which is the name that `cargo chef`
+gives to the process of collecting all the information needed to build the application
+dependencies.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Chef Prepare (look at project and see wat we need)
+FROM chef AS recipe
+WORKDIR /build/src
+COPY . /build/src
+RUN cargo chef prepare --recipe-path /build/recipe.json
+```
+
+</CodeBlock>
+
+Then, cargo dependencies are built using using the recipe created in the previous stage.
+`cargo nextest` has a subcommand to generate and archive the artifact of the build.
+We are using it to package and pass the application from one stage to another.
+
+Dependencies are archived but they are not used independently. That line just tests
+that the dependencies could be archived.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Cook (release)
+FROM chef AS dependencies
+WORKDIR /build/src
+COPY --from=recipe /build/recipe.json /build/recipe.json
+RUN cargo chef cook --tests --benches --examples --workspace --all-targets --all-features --recipe-path /build/recipe.json --release
+RUN cargo nextest archive --tests --benches --examples --workspace --all-targets --all-features --archive-file /build/temp.tar.zst --release  ; rm -f /build/temp.tar.zst
+```
+
+</CodeBlock>
+
+In the following stage we build the application. The `cargo nextest archive` command builds
+and archives the application.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Build Archive (release)
+FROM dependencies AS build
+WORKDIR /build/src
+COPY . /build/src
+RUN cargo nextest archive --tests --benches --examples --workspace --all-targets --all-features --archive-file /build/full-example.tar.zst --release
+```
+
+</CodeBlock>
+
+Now, that we have successfully built the application, we can run the tests. We
+extract the application from the archived artifacts and run the tests.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Extract and Test (release)
+FROM tester as test
+WORKDIR /test
+COPY . /test/src
+COPY --from=build \
+  /build/full-example.tar.zst \
+  /test/full-example.tar.zst
+# It compiles without running the tests to make sure there are no problems with
+# the archive.
+RUN cargo nextest run --workspace-remap /test/src/ --extract-to /test/src/ --no-run --archive-file /test/full-example.tar.zst
+# We actually run the tests
+RUN cargo nextest run --workspace-remap /test/src/ --target-dir-remap /test/src/target/ --cargo-metadata /test/src/target/nextest/cargo-metadata.json --binaries-metadata /test/src/target/nextest/binaries-metadata.json
+# We copy the application binary to a specified location so we can get it from
+# there in the final runtime stage.
+RUN mkdir -p /app/bin/; cp -l /test/src/target/release/full-example /app/bin/full-example
+# Since we use su-exec. We need to run the container as root.
+RUN chown -R root:root /app; chmod -R u=rw,go=r,a+X /app; chmod -R a+x /app/bin
+```
+
+</CodeBlock>
+
+Once the application has been built and tested we prepare the runtime. We start
+from a minimum "distroless" image variant. We add an entrypoint to setup the application
+and also to make sure we don't use the `root` user to run it. The entrypoint just
+runs the application provided as an argument, in our case, our application in `debug` or
+`release` mode, depending of which one you want to run.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Runtime
+FROM gcr.io/"distroless/cc-debian12:debug as runtime
+RUN ["/busybox/cp", "-sp", "/busybox/sh","/busybox/cat","/busybox/ls","/busybox/env", "/bin/"]
+COPY --from=gcc --chmod=0555 /usr/local/bin/su-exec /bin/su-exec
+ARG USER_ID=1000
+COPY --chmod=0555 ./share/container/entry_script_sh /usr/local/bin/entry.sh
+ENTRYPOINT ["/usr/local/bin/entry.sh"]
+```
+
+</CodeBlock>
+
+Finally, we add the `CMD` instruction so we can execute the application. The
+entrypoint script only runs the application you pass as the first argument. This
+stage is not merge into the previous because in the final version there are two
+final runtimes: `debug` and `release`.
+
+<CodeBlock lang="dockerfile">
+
+```dockerfile
+## Release Runtime
+FROM runtime as release
+COPY --from=test /app/ /usr/
+CMD ["/usr/bin/full-example"]
+```
+
+</CodeBlock>
+
+## Other Good Practices
+
+- **Minimalism**: We strive to keep our Dockerfiles lean by only including essential components.
+- **Explicit versions**: At least with the minor version number, so you do not get unexpected broken compatibility but you can apply security and bug patches.
+- **Regular Updates**: Periodically updating the base image and dependencies to benefit from security patches and updates.
+- **Health Checks**: Implementing Docker health checks to monitor the state and health of our containerized application.
+
+## Other Considerations
+
+- Since we are using `su-exec` we need to run the containers as root. We have not
+  checked if this configuration works when you setup docker in [Rootless mode](https://docs.docker.com/engine/security/rootless/).
+- Also, although we mostly mention docker in this article, the `Containerfile` works
+  with other tools to manage containers like [Podman](https://podman.io/).
+
+## Links
+
+Simple tutorials:
+
+- [Docker image for Rust backend: learn how to](https://tms-dev-blog.com/lean-docker-image-for-rust-backend/)
+- [Getting Started with Rust and Docker](https://collabnix.com/getting-started-with-rust-and-docker/) by [Ajeet Raina](https://collabnix.com/author/ajeetraina/).
+- [Rust Docker Tutorial](https://tutorialedge.net/rust/rust-docker-tutorial/).
+- [Build your Rust image](https://docs.docker.com/language/rust/build-images/)
+
+Comprehensive articles like this:
+
+- [First steps with Docker + Rust](https://dev.to/rogertorres/first-steps-with-docker-rust-30oi) by [Roger Torres](https://dev.to/rogertorres).
+
+Demos:
+
+- [Simple dockerized Rust/Axum based HTTP server for demo purposes](https://github.com/hseeberger/hello-rs) by [
+  Heiko Seeberger](https://github.com/hseeberger).
+
+Development using Docker:
+
+- [Rust Development with Docker](https://www.youtube.com/watch?v=kh1GMRFkzT4&t=2s).
+- [Develop your Rust application](https://docs.docker.com/language/rust/develop/)
+
+Deployments using docker:
+
+- [How I deployed a Rust web-app using the Rocket framework with Docker](https://medium.com/@anirudhmurali/how-i-deployed-a-rust-web-app-using-the-rocket-framework-with-docker-424da99b1d8a)
+- [Deploy a Rust Web App With Rocket](https://www.koyeb.com/tutorials/deploy-a-rust-web-app-with-rocket).
+
+Minimum sized container images:
+
+- [min-sized-rust](https://github.com/johnthagen/min-sized-rust#containers) by [johnthagen](https://github.com/johnthagen).
+
+Caching dependencies:
+
+- [Packaging a Rust web service using Docker](https://blog.logrocket.com/packaging-a-rust-web-service-using-docker/).
+- [Plumbing the Deps of the Crate: Caching Rust Docker Builds](https://dev.to/mgattozzi/plumbing-the-deps-of-the-crate-caching-rust-docker-builds-2e48).
+- [Cache Rust dependencies with Docker build](https://stackoverflow.com/questions/58473606/cache-rust-dependencies-with-docker-build).
+
+Don't run containers as root:
+
+- [Manage Docker as a non-root user](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user).
+- [Run the Docker daemon as a non-root user (Rootless mode)](https://docs.docker.com/engine/security/rootless/).
+- [Docker daemon attack surface](https://docs.docker.com/engine/security/#docker-daemon-attack-surface).
+- [Why Processes In Docker Containers Shouldn't Run as Root](https://www.howtogeek.com/devops/why-processes-in-docker-containers-shouldnt-run-as-root/).
+- [The Ultimate Docker Security Best Practices for Your Node.js Application](https://www.clickittech.com/devops/docker-security-best-practices/).
+- [Should I run things inside a docker container as non root for safety?](https://stackoverflow.com/questions/68155641/should-i-run-things-inside-a-docker-container-as-non-root-for-safety).
+- [Docker Tips: Running a Container With a Non Root User](https://betterprogramming.pub/running-a-container-with-a-non-root-user-e35830d1f42a) by [Luc Juggery](https://lucjuggery.medium.com/).
+- [Basic Setup and Use of Podman in a Rootless environment](https://github.com/containers/podman/blob/main/docs/tutorials/rootless_tutorial.md).
+- [Understanding how uid and gid work in Docker containers](https://medium.com/@mccode/understanding-how-uid-and-gid-work-in-docker-containers-c37a01d01cf).
+
+## Conclusion
+
+We hope you find this guide useful. Let us know what you think about it!
+
+We want this article to be a collective effort to document good practices about
+Rust and Containers, so we would like to have reviews, comments, new sections, etcetera.
+
+If you see something wrong or you want to contribute by:
+
+- Adding new sections.
+- Fixing typos.
+- Making it clearer.
+- Adding links.
+- Or whatever you think it could be interesting to have,
+
+please open an [issue](https://github.com/torrust/torrust-website/issues) or a [PR](https://github.com/torrust/torrust-website/pulls).
+
+If you have any questions or issues please open an issue on the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index: <https://github.com/torrust/torrust-index-backend/issues>
+- Torrust Website: <https://github.com/torrust/torrust-index-frontend/issues>
+- Containerizing Rust Applications Examples: <https://github.com/torrust/containerizing-rust-apps-examples>
+
+We very welcome any contributions to the projects or [this article](https://github.com/torrust/torrust-website/issues).
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/deploying-torrust-to-production/+page.md b/src/routes/v2/(blog-article)/deploying-torrust-to-production/+page.md
new file mode 100644
index 0000000..1cbed2f
--- /dev/null
+++ b/src/routes/v2/(blog-article)/deploying-torrust-to-production/+page.md
@@ -0,0 +1,1146 @@
+---
+title: Deploying Torrust To Production
+slug: deploying-torrust-to-production
+coverImage: /images/posts/deploying-torrust-to-production/deploy-torrust-to-a-digital-ocean-droplet.png
+date: 2023-12-20T00:00:00.000Z
+updated:
+excerpt: Dive into our step-by-step tutorial on deploying a BitTorrent Index and Tracker, written in Rust, on a Digital Ocean droplet. From initial server setup to advanced configurations, this guide is designed for both non-developers and tech-savvy users, ensuring a seamless, production-ready deployment.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Tutorial
+  - Deployment
+  - Production
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Requirements](#requirements)
+- [Initial Server Setup](#initial-server-setup)
+  - [Setup SSH Keys](#setup-ssh-keys)
+  - [Install Docker](#install-docker)
+  - [Install Docker Compose](#install-docker-compose)
+  - [Install SQLite](#install-sqlite)
+- [Setup The DNS](#setup-the-dns)
+- [Install The Application](#install-the-application)
+  - [Without Certificates](#without-certificates)
+  - [Generate Certificates With Let's Encrypt](#generate-certificates-with-lets-encrypt)
+  - [Change Nginx Configuration To Use Certificates](#change-nginx-configuration-to-use-certificates)
+  - [Setup Cronjob To Renew Certificates](#setup-cronjob-to-renew-certificates)
+- [Exposed Services](#exposed-services)
+  - [Firewall](#firewall)
+  - [Health checks](#health-checks)
+- [Troubleshooting](#troubleshooting)
+- [Maintenance](#maintenance)
+  - [Backups](#backups)
+  - [Monitoring](#monitoring)
+- [Cost](#cost)
+- [Other Considerations](#other-considerations)
+- [Links](#links)
+- [Conclusion](#conclusion)
+
+</PostTable>
+
+<PostBody>
+
+## Introduction
+
+Welcome to our guide on deploying a BitTorrent Index and Tracker. We'll walk you through each step, explaining the process in a user-friendly manner, so you can understand the magic behind hosting a powerful, Rust-based application on the cloud.
+
+This guide provides detailed, technical steps for deploying your Rust-based BitTorrent Index and Tracker on a Digital Ocean droplet. You'll find precise commands and configurations to ensure a smooth, efficient setup.
+
+You can find the docker compose configuration used in this guide on the following GitHub repo:
+
+<https://github.com/torrust/torrust-compose/tree/main/droplet>
+
+Although we are using a droplet, this tutorial is intended to be so generic that
+you should be able to setup the services in any virtual machine with docker and docker compose.
+
+This tutorial is based on the Digital Ocean tutorial:
+
+[How To Secure a Containerized Node.js Application with Nginx, Let's Encrypt, and Docker Compose](https://www.digitalocean.com/community/tutorials/how-to-secure-a-containerized-node-js-application-with-nginx-let-s-encrypt-and-docker-compose).
+
+We have only changed the docker compose configuration and some steps to configure the **Torrust Index and Tracker** instead of
+the sample node application.
+
+After finishing this tutorial you will have these public services available (with your own domain):
+
+- Torrust Index: <https://index.torrust-demo.com>
+- Torrust HTTP Tracker: <https://tracker.torrust-demo.com/announce>
+- Torrust UDP Tracker: <udp://tracker.torrust-demo.com:6969/announce>
+
+## Requirements
+
+You will need:
+
+- A Digital Ocean account.
+- A Digital Ocean virtual machine (droplet) with Ubuntu 22.04.2 LTS.
+- Docker, Docker Compose, SQLite3 and Git installed on the server.
+
+We will explain how to install the required dependencies in the Ubuntu server.
+
+### Server
+
+A Digital Ocean Droplet with a configuration similar to this:
+
+- **Datacenter**: Frankfurt (FRA1).
+- **Image**: Ubuntu 22.04 (LTS) x64.
+- **Droplet Type**: Shared CPU (Basic).
+- **CPU options**: Regular (Disk Type: SSD).
+
+Resources:
+
+- 1 GB/1CPU.
+- 25 GB SS Disk.
+- 1000 GB transfer.
+
+Features:
+
+- Backups enabled.
+- With improved metrics monitoring and alerting.
+
+### Software
+
+- Ubuntu 22.04.2 LTS (already installed in the droplet)
+- Docker version 24.0.7, build afdd53b.
+- Docker Compose version v2.3.3.
+- SQLite3 version 3.37.2 2022-01-06 13:25:41 872ba256cbf61d9290b571c0e6d82a20c224ca3ad82971edc46b29818d5dalt1.
+- Git version 2.34.1 (only for the installation).
+
+The Docker images used by this tutorial are:
+
+<CodeBlock lang="terminal">
+
+```console
+$ docker images --digests
+REPOSITORY          TAG               DIGEST                                                                    IMAGE ID       CREATED       SIZE
+torrust/tracker     develop           sha256:5589eaf57af277feda6eca6f841859fd2aa05af7deafca546ad0a17fe36d8e51   c42f0cce3304   4 days ago    160MB
+nginx               mainline-alpine   sha256:3923f8de8d2214b9490e68fd6ae63ea604deddd166df2755b788bef04848b9bc   01e5c69afaf6   2 weeks ago   42.6MB
+torrust/index       develop           sha256:69b12dfcb9c47267bd314f4869dfce7585d3f2b172200ef0d7d7bb776e209fe6   a3db4d4e5d6a   2 weeks ago   64.9MB
+torrust/index-gui   develop           sha256:b30deb84cdee8fa34e4d3783ce2f467542e6fdc13a14dd6bbed879e2e2b82bcb   4f6e446cb009   2 weeks ago   175MB
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  We will update them to use a concrete tag v3.0 after releasing it.
+</Callout>
+
+### Domain
+
+You will need a domain. We are using "torrust-demo.com" in this tutorial.
+
+## Initial Server Setup
+
+Starting off, we'll set up a virtual server using Ubuntu 22.04. Think of it as preparing a new computer for your application, ensuring it's ready to run smoothly.
+
+This section covers the initial configuration of your Ubuntu 22.04 server, focusing on essential security and performance optimizations.
+
+<Callout type="info">
+  Disclaimer: For the initial server setup we only highlight the main points. We provide the links to Digital Ocean tutorials
+  where you will find detailed information.
+</Callout>
+
+Please refer to [Digital Ocean Documentation](https://docs.digitalocean.com/) for more information about how to create projects and droplets. Projects are the way DO (Digital Ocean) organizes resources (virtual machines, databases, domains, etc.). We have a project called "torrust-demo.com".
+
+Once you have created your project and droplet you can follow the [Digital Ocean guide to setup a new Ubuntu server](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-22-04).
+
+For this tutorial we have used our demo environment.
+
+In this first step you will:
+
+- Create a virtual machine (droplet).
+- Access the virtual machine using the `root` account.
+- Create a new user `torrust`.
+- Access the server using the new account `torrust`.
+
+After creating the droplet you should be able to connect by using SSH with the `root` account providing the password you set
+during the droplet creation:
+
+<CodeBlock lang="bash">
+
+```bash
+ssh root@139.59.150.216
+```
+
+</CodeBlock>
+
+After logging in you can create the new user account:
+
+<CodeBlock lang="bash">
+
+```bash
+adduser torrust
+usermod -aG sudo torrust
+```
+
+</CodeBlock>
+
+The user is added to the sudo group you can can execute command as root when needed.
+
+### Setup SSH Keys
+
+Security is key! Setting up SSH keys is like creating a special passcode for safe and secure access to your server.
+
+Follow the [Digital Ocean tutorial](https://www.digitalocean.com/community/tutorials/how-to-set-up-ssh-keys-on-ubuntu-22-04) to establish secure SSH key authentication, enhancing the security of your server connections.
+
+You have to generate a new key and copy it to the server:
+
+<CodeBlock lang="bash">
+
+```bash
+ssh-copy-id -i ~/.ssh/torrust_rsa.pub torrust@139.59.150.216
+```
+
+</CodeBlock>
+
+If all went fine you should be able to login to the server with your SSH key.
+
+<CodeBlock lang="bash">
+
+```bash
+ssh torrust@139.59.150.216
+```
+
+</CodeBlock>
+
+### Install Docker
+
+Docker is a tool that lets you run applications in a consistent environment. It's like having a universal app runner that works the same everywhere.
+
+You can also follow the DO guide: [How To Install and Use Docker on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-22-04).
+
+In short, you only need to execute some commands:
+
+<CodeBlock lang="bash">
+
+```bash
+sudo apt update
+sudo apt install apt-transport-https ca-certificates curl software-properties-common
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
+echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+sudo apt update
+apt-cache policy docker-ce
+sudo apt install docker-ce
+sudo systemctl status docker
+```
+
+</CodeBlock>
+
+If you want to execute docker without sudo you will need to execute some more commands:
+
+<CodeBlock lang="bash">
+
+```bash
+sudo usermod -aG docker ${USER}
+su - ${USER}
+```
+
+</CodeBlock>
+
+Make sure docker is running with `docker run hello-world`.
+
+### Install Docker Compose
+
+Docker Compose helps in running complex apps easily. It's like a recipe that tells Docker how to prepare and serve your app.
+
+You can follow the Digital Ocean Tutorial: [How To Install and Use Docker Compose on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-compose-on-ubuntu-22-04)
+
+<CodeBlock lang="bash">
+
+```bash
+mkdir -p ~/.docker/cli-plugins/
+curl -SL https://github.com/docker/compose/releases/download/v2.3.3/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose
+chmod +x ~/.docker/cli-plugins/docker-compose
+```
+
+</CodeBlock>
+
+And also make sure it's installed correctly with `docker compose version`.
+
+### Install SQLite
+
+SQLite is a simple database system. You won't needed if you use MySQL for both the Index and Tracker. In this tutorial
+we will use it.
+
+<CodeBlock lang="bash">
+
+```bash
+sudo apt update
+sudo apt install sqlite3
+```
+
+</CodeBlock>
+
+You can check if it's installed correctly with `sqlite3 --version`.
+
+You can execute queries to get the Tracker or Index data connecting with:
+
+<CodeBlock lang="bash">
+
+```bash
+$ sqlite3 ./storage/index/lib/database/sqlite3.db
+SQLite version 3.37.2 2022-01-06 13:25:41
+Enter ".help" for usage hints.
+sqlite>
+```
+
+</CodeBlock>
+
+Some useful commands are:
+
+- `.help`: show help.
+- `.tables`: list tables.
+- `.quit`: exit.
+
+## Setup The DNS
+
+Before running the application we have to setup the DNS. You can load the application using your domain instead of the droplet IP.
+
+<Callout type="info">
+  The droplet has an IP that can be used to setup the DNS, but we recommend using an reserved IP. You can link the reserved IP to the droplet.
+</Callout>
+
+First at all, you need to change your name servers and use the ones from Digital Ocean. You have to find out how to do that
+in your domain provider.
+
+Then you need to create two `A` records to point the domains to the droplet IP (or the reserved IP if you are using one).
+
+Here is how the DNS configuration looks like for our demo:
+
+<Image src="/images/posts/deploying-torrust-to-production/dns-configuration.png" alt="Create" />
+
+### BEP 34
+
+As you can see in our DNS configuration we have a `TXT` record for the tracker with this value:
+
+```text
+BITTORRENT UDP:6969 TCP:443
+```
+
+That record implements the [BEP 34 DNS Tracker Preferences](https://www.bittorrent.org/beps/bep_0034.html).
+
+That allows administrators to declare the port and the service priorities for a tracker domain. In our case, we have two different trackers running on ports `6969` and `443` and we prioritize the UDP tracker.
+
+Some services related to tracker (for instance <https://newtrackon.com>) use this DNS record to verify tracker URLs.
+
+## Install The Application
+
+First, we will install the application on port `80` because we need a live app to generate the HTTPs certificates with
+Let's Encrypt. Once we generate the certificates we can change the configuration to serve the application on port `443`.
+
+### Without certificates
+
+We'll start by launching your app in a basic, non-secure mode. Initial deployment steps will be covered, focusing on functionality before implementing SSL/TLS certificates. We need to run the application in order to generate certificates with Let's Encrypt.
+
+First, we need to get the docker compose configuration. You can download it directly from the [Torrust Compose GitHub repo](https://github.com/torrust/torrust-compose) or you can use Git:
+
+<CodeBlock lang="bash">
+
+```bash
+cd \\
+  && mkdir -p github/torrust \\
+  && cd torrust/  \\
+  && git clone --single-branch --branch main https://github.com/torrust/torrust-compose.git  \\
+  && cd torrust-compose/  \\
+  && git status  \\
+  && cd droplet/
+```
+
+</CodeBlock>
+
+If you use Git you will need to install it in the server. Follow the ["How To Install Git on Ubuntu 22.04"](https://www.digitalocean.com/community/tutorials/how-to-install-git-on-ubuntu-22-04) guide.
+
+After cloning the repository you have to run the install script:
+
+<CodeBlock lang="bash">
+
+```bash
+$ ./bin/install.sh
+Creating compose .env './.env'
+Creating proxy config file: './storage/proxy/etc/nginx-conf/nginx.conf'
+Creating index database: './storage/index/lib/database/sqlite3.db'
+Creating index configuration: './storage/index/etc/index.toml'
+Creating tracker database: './storage/tracker/lib/database/sqlite3.db'
+Creating tracker configuration: './storage/tracker/etc/tracker.toml'
+```
+
+</CodeBlock>
+
+The script will create some needed directories and empty SQLite databases:
+
+<CodeBlock lang="bash">
+
+```bash
+$ tree storage/
+storage/
+├── certbot
+│   ├── etc
+│   └── lib
+├── dhparam
+├── index
+│   ├── etc
+│   │   └── index.toml
+│   └── lib
+│       └── database
+│           └── sqlite3.db
+├── proxy
+│   ├── etc
+│   │   └── nginx-conf
+│   │       └── nginx.conf
+│   └── webroot
+└── tracker
+    ├── etc
+    │   └── tracker.toml
+    └── lib
+        └── database
+            └── sqlite3.db
+
+17 directories, 5 files
+
+```
+
+</CodeBlock>
+
+Now you can continue with some customizations. You can adjust the default configuration for all services
+or leave the default values. But at least you must change the domain and the secrets.
+
+First open the `.env` file and find these environment variables:
+
+- `TORRUST_INDEX_GUI_API_BASE_URL`
+- `TORRUST_INDEX_CONFIG_OVERRIDE_TRACKER__TOKEN`
+- `TORRUST_INDEX_CONFIG_OVERRIDE_AUTH__SECRET_KEY`
+- `TORRUST_TRACKER_CONFIG_OVERRIDE_HTTP_API__ACCESS_TOKENS__ADMIN`
+
+Replace the value for `TORRUST_INDEX_GUI_API_BASE_URL` with your domain:
+
+```text
+TORRUST_INDEX_GUI_API_BASE_URL='http://index.your-domain.com/api/v1'
+```
+
+You can generate the Tracker API token and the Auth Secret Key with:
+
+<CodeBlock lang="bash">
+
+```bash
+ gpg --armor --gen-random 1 40
+jcrmbzlGyeP7z53TUQtXmtltMb5TubsIE9e0DPLnS4Ih29JddQw5JA==
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  NOTICE: We are not sending emails from the application because user's email validation is disabled on registration for the demo. If you want to enable email validation you will need to provide the SMTP configuration including the password in the `storage/index/etc/index.toml` config file.
+</Callout>
+
+Now, you should be able to run the application with the following command:
+
+<CodeBlock lang="bash">
+
+```bash
+docker compose up --build --detach
+```
+
+</CodeBlock>
+
+If you have reached this point, congratulations! you already have these live services:
+
+- Torrust Index: <http://index.your-domain.com>
+- Torrust HTTP Tracker: <http://tracker.your-domain.com/announce>
+- Torrust UDP Tracker: <udp://tracker.your-domain.com:6969/announce>
+
+In the next sections we will describe how to use Let's Encrypt to generate certificates to use HTTPs for the Index website and HTTP Tracker.
+
+### Generate Certificates With Let's Encrypt
+
+Let's Encrypt provides free certificates. You'll learn how to obtain and configure Let's Encrypt SSL certificates for secure HTTPS connections.
+
+First, you need to log in the "certbot" container. [Certbot](https://certbot.eff.org/) is a free, open source software tool for automatically (using Let’s Encrypt certificates) enable HTTPS.
+
+<CodeBlock lang="bash">
+
+```bash
+docker compose run --entrypoint /bin/sh certbot
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  Notice that the previous command recreates the docker containers so you site will be down for some seconds.
+</Callout>
+
+Once you are logged in the certbot container you need to execute these certbot commands to generate the staging certificates:
+
+<CodeBlock lang="bash">
+
+```bash
+certbot certonly --webroot --webroot-path=/var/www/html --email email@example.com --agree-tos --no-eff-email --staging -d index.torrust-demo.com
+certbot certonly --webroot --webroot-path=/var/www/html --email email@example.com --agree-tos --no-eff-email --staging -d tracker.torrust-demo.com
+```
+
+</CodeBlock>
+
+Replace `email@example.com` with your email.
+
+For the production certificates you can execute the same command but removing the flag `--staging`:
+
+<CodeBlock lang="bash">
+
+```bash
+certbot certonly --webroot --webroot-path=/var/www/html --email email@example.com --agree-tos --no-eff-email --force-renewal -d index.torrust-demo.com
+certbot certonly --webroot --webroot-path=/var/www/html --email email@example.com --agree-tos --no-eff-email --force-renewal -d tracker.torrust-demo.com
+```
+
+</CodeBlock>
+
+In the directory `storage/certbot/etc/live` you should have at least one directory per domain.
+
+### Change Nginx Configuration To Use Certificates
+
+Once we have the certificates, we'll tell our server (Nginx) to use them, ensuring a secure website. Detailed steps to modify your Nginx configuration for SSL implementation will be provided.
+
+#### Generate The Diffie-Hellman Key
+
+<CodeBlock lang="bash">
+
+```bash
+sudo openssl dhparam -out /home/torrust/github/torrust/torrust-compose/droplet/storage/dhparam/dhparam-2048.pem 2048
+```
+
+</CodeBlock>
+
+#### Update Nginx Configuration
+
+Edit the file `./storage/proxy/etc/nginx-conf/nginx.conf` and uncomment all the commented lines for HTTPs servers:
+
+<CodeBlock lang="nginx">
+
+```nginx
+server
+{
+  listen 443 ssl http2;
+  listen [::]:443 ssl http2;
+  server_name index.torrust-demo.com;
+
+  server_tokens off;
+
+  ssl_certificate /etc/letsencrypt/live/index.torrust-demo.com-0001/fullchain.pem;
+  ssl_certificate_key /etc/letsencrypt/live/index.torrust-demo.com-0001/privkey.pem;
+
+  ssl_buffer_size 8k;
+
+  ssl_dhparam /etc/ssl/certs/dhparam-2048.pem;
+
+  ssl_protocols TLSv1.2;
+  ssl_prefer_server_ciphers on;
+
+  ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
+
+  ssl_ecdh_curve secp384r1;
+  ssl_session_tickets off;
+
+  ssl_stapling on;
+  ssl_stapling_verify on;
+  resolver 8.8.8.8;
+
+  location ^~/api/
+  {
+    rewrite ^/api/(.*)$ /$1 break;
+    try_files $uri @index;
+  }
+
+  location /
+  {
+    try_files $uri @index-gui;
+  }
+
+  location @index
+  {
+    proxy_pass http://index:3001;
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "no-referrer-when-downgrade" always;
+    add_header Content-Security-Policy "default-src * data: 'unsafe-eval' 'unsafe-inline'" always;
+    #add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
+    # enable strict transport security only if you understand the implications
+  }
+
+  location @index-gui
+  {
+    proxy_pass http://index-gui:3000;
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "no-referrer-when-downgrade" always;
+    add_header Content-Security-Policy "default-src * data: 'unsafe-eval' 'unsafe-inline'" always;
+    #add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
+    # enable strict transport security only if you understand the implications
+  }
+
+  root /var/www/html;
+  index index.html index.htm index.nginx-debian.html;
+}
+
+server
+{
+  listen 443 ssl http2;
+  listen [::]:443 ssl http2;
+  server_name tracker.torrust-demo.com;
+
+  server_tokens off;
+
+  ssl_certificate /etc/letsencrypt/live/tracker.torrust-demo.com/fullchain.pem;
+  ssl_certificate_key /etc/letsencrypt/live/tracker.torrust-demo.com/privkey.pem;
+
+  ssl_buffer_size 8k;
+
+  ssl_dhparam /etc/ssl/certs/dhparam-2048.pem;
+
+  ssl_protocols TLSv1.2;
+  ssl_prefer_server_ciphers on;
+
+  ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
+
+  ssl_ecdh_curve secp384r1;
+  ssl_session_tickets off;
+
+  ssl_stapling on;
+  ssl_stapling_verify on;
+  resolver 8.8.8.8;
+
+  location /api/
+  {
+    try_files $uri @tracker-api;
+  }
+
+  location /
+  {
+    try_files $uri @tracker-http;
+  }
+
+  location @tracker-api
+  {
+    proxy_pass http://tracker:1212;
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "no-referrer-when-downgrade" always;
+    add_header Content-Security-Policy "default-src * data: 'unsafe-eval' 'unsafe-inline'" always;
+    #add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
+    # enable strict transport security only if you understand the implications
+  }
+
+  location @tracker-http
+  {
+    proxy_pass http://tracker:7070;
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "no-referrer-when-downgrade" always;
+    add_header Content-Security-Policy "default-src * data: 'unsafe-eval' 'unsafe-inline'" always;
+    #add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
+    # enable strict transport security only if you understand the implications
+
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+  }
+
+  root /var/www/html;
+  index index.html index.htm index.nginx-debian.html;
+}
+```
+
+</CodeBlock>
+
+Make sure you also change the domains:
+
+- index.torrust-demo.com
+- tracker.torrust-demo.com
+
+You also have to change the API base URL in the `.env` file:
+
+```text
+TORRUST_INDEX_GUI_API_BASE_URL=https://index.torrust-demo.com/api/v1
+```
+
+Replace it from `http://index.torrust-demo.com/api/v1` to `https://index.torrust-demo.com/api/v1`.
+
+After changing the Nginx configuration you need to restart the Nginx server:
+
+<CodeBlock lang="bash">
+
+```bash
+docker compose --ansi never restart proxy
+```
+
+</CodeBlock>
+
+### Setup Cronjob To Renew Certificates
+
+Certificates expire, so we'll set up an automatic renewal system, like a subscription that renews itself. We will set up an automate SSL certificate renewal using cronjobs to maintain continuous security.
+
+We will use crontab to execute a command every day:
+
+<CodeBlock lang="bash">
+
+```bash
+sudo crontab -e
+```
+
+</CodeBlock>
+
+Add the following crontab line:
+
+<CodeBlock lang="text">
+
+```text
+0 12 * * * /home/torrust/github/torrust/torrust-compose/droplet/bin/ssl_renew.sh >> /var/log/cron.log 2>&1
+```
+
+</CodeBlock>
+
+You can check the cronjob output with:
+
+<CodeBlock lang="bash">
+
+```bash
+tail -f /var/log/cron.log
+```
+
+</CodeBlock>
+
+After generating the certificates and renewing them you should have a certbot directory structure similar to this:
+
+<CodeBlock lang="bash">
+
+```bash
+$ sudo tree storage/certbot/
+[sudo] password for torrust:
+storage/certbot/
+├── etc
+│   ├── accounts
+│   │   ├── acme-staging-v02.api.letsencrypt.org
+│   │   │   └── directory
+│   │   │       └── b39c03e978*****df8366ab6539
+│   │   │           ├── meta.json
+│   │   │           ├── private_key.json
+│   │   │           └── regr.json
+│   │   └── acme-v02.api.letsencrypt.org
+│   │       └── directory
+│   │           └── 441a435b0f8*****cc6dd22f34468
+│   │               ├── meta.json
+│   │               ├── private_key.json
+│   │               └── regr.json
+│   ├── archive
+│   │   ├── index.torrust-demo.com
+│   │   │   ├── cert1.pem
+│   │   │   ├── chain1.pem
+│   │   │   ├── fullchain1.pem
+│   │   │   └── privkey1.pem
+│   │   ├── index.torrust-demo.com-0001
+│   │   │   ├── cert1.pem
+│   │   │   ├── cert2.pem
+│   │   │   ├── chain1.pem
+│   │   │   ├── chain2.pem
+│   │   │   ├── fullchain1.pem
+│   │   │   ├── fullchain2.pem
+│   │   │   ├── privkey1.pem
+│   │   │   └── privkey2.pem
+│   │   └── tracker.torrust-demo.com
+│   │       ├── cert1.pem
+│   │       ├── cert2.pem
+│   │       ├── cert3.pem
+│   │       ├── chain1.pem
+│   │       ├── chain2.pem
+│   │       ├── chain3.pem
+│   │       ├── fullchain1.pem
+│   │       ├── fullchain2.pem
+│   │       ├── fullchain3.pem
+│   │       ├── privkey1.pem
+│   │       ├── privkey2.pem
+│   │       └── privkey3.pem
+│   ├── live
+│   │   ├── README
+│   │   ├── index.torrust-demo.com
+│   │   │   ├── README
+│   │   │   ├── cert.pem -> ../../archive/index.torrust-demo.com/cert1.pem
+│   │   │   ├── chain.pem -> ../../archive/index.torrust-demo.com/chain1.pem
+│   │   │   ├── fullchain.pem -> ../../archive/index.torrust-demo.com/fullchain1.pem
+│   │   │   └── privkey.pem -> ../../archive/index.torrust-demo.com/privkey1.pem
+│   │   ├── index.torrust-demo.com-0001
+│   │   │   ├── README
+│   │   │   ├── cert.pem -> ../../archive/index.torrust-demo.com-0001/cert2.pem
+│   │   │   ├── chain.pem -> ../../archive/index.torrust-demo.com-0001/chain2.pem
+│   │   │   ├── fullchain.pem -> ../../archive/index.torrust-demo.com-0001/fullchain2.pem
+│   │   │   └── privkey.pem -> ../../archive/index.torrust-demo.com-0001/privkey2.pem
+│   │   └── tracker.torrust-demo.com
+│   │       ├── README
+│   │       ├── cert.pem -> ../../archive/tracker.torrust-demo.com/cert3.pem
+│   │       ├── chain.pem -> ../../archive/tracker.torrust-demo.com/chain3.pem
+│   │       ├── fullchain.pem -> ../../archive/tracker.torrust-demo.com/fullchain3.pem
+│   │       └── privkey.pem -> ../../archive/tracker.torrust-demo.com/privkey3.pem
+│   ├── renewal
+│   │   ├── index.torrust-demo.com-0001.conf
+│   │   ├── index.torrust-demo.com.conf
+│   │   └── tracker.torrust-demo.com.conf
+│   └── renewal-hooks
+│       ├── deploy
+│       ├── post
+│       └── pre
+└── lib
+
+22 directories, 49 files
+```
+
+</CodeBlock>
+
+## Exposed services
+
+After finishing the instalaltion the main available services are:
+
+- The Index: <http://index.torrust-demo.com/>
+- The HTTP Tracker: <https://tracker.torrust-demo.com/announce>
+- The UDP Tracker: <udp://tracker.torrust-demo.com:6969/announce>
+
+But there are some other exposed ports. In addition to the SSH port (22), when you run the container you'll expose all the following ports on the server:
+
+- 80 (proxy)
+- 443 (proxy)
+- 3001 (index-gui)
+- 3000 (index)
+- 6969 (tracker)
+- 7070 (tracker)
+- 1212 (tracker)
+
+You should have access to all exposed services by default.
+
+You should be able to access the services directly (with no proxy) connecting to the containers:
+
+- Index GUI (webapp): <http://index.torrust-demo.com:3000>
+- Index (API): <http://tracker.torrust-demo.com:3001>
+- Tracker (HTTP): <http://tracker.torrust-demo.com:7070/announce>
+- Tracker (UDP): udp://tracker.torrust-demo.com:6969
+- Tracker (API): <http://tracker.torrust-demo.com:1212>
+
+But you should also be able to connect to all services except the UDP Tracker via the Nginx proxy both with HTTP
+or HTTPs:
+
+HTTP access to services via proxy:
+
+- Index GUI (webapp): <http://index.torrust-demo.com>
+- Index (API): <http://index.torrust-demo.com/api>
+
+- Tracker (HTTP): <http://tracker.torrust-demo.com/announce>
+- Tracker (API): <http://tracker.torrust-demo.com/api>
+
+HTTPs access to services via proxy:
+
+- Index GUI (webapp): <https://index.torrust-demo.com>
+- Index (API): <https://index.torrust-demo.com/api>
+
+- Tracker (HTTP): <https://tracker.torrust-demo.com/announce>
+- Tracker (API): <https://tracker.torrust-demo.com/api>
+
+You can disable both, direct access to the container (without using the Nginx proxy) and also access without certificates (HTTP). In that case you only need to expose port: `443` and `6969`. In order to do that you will
+need to enable a firewall on the server or the Digital Ocean firewall.
+
+<Callout type="info">
+  Notice: The UDP tracker is not available via the proxy. If you want all requests to go through the
+  proxy you need to change the Nginx configuration to set up a UDP proxy. There is a discussion
+  on the Tracker repository on GitHub about how to setup the proxy for the UDP tracker.
+</Callout>
+
+### Firewall
+
+By default there is no firewall on the server. If you want to enable the firewall you have two options:
+
+- [Setup your own firewall on the server](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-firewall-with-ufw-on-ubuntu-22-04).
+- [Enable the Digital Ocean firewall](https://docs.digitalocean.com/products/networking/firewalls/getting-started/quickstart/).
+
+You can enable the UFW firewall on the server by following the Digital Ocean guide:
+
+[How To Set Up a Firewall with UFW on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-firewall-with-ufw-on-ubuntu-22-04).
+
+For example, you can allow only the ports `22`, `43` and `6969` with the following command:
+
+<CodeBlock lang="bash">
+
+```bash
+sudo ufw default deny incoming
+sudo ufw default allow outgoing
+sudo ufw allow ssh
+sudo ufw allow 443
+sudo ufw allow 6969/udp
+sudo ufw enable
+sudo ufw status verbose
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  However, there is a problem with setting up your own firewall. By default, Docker manipulates iptables to set up network isolation. However, this can interfere with UFW. To fix this, you need to tell Docker not to modify iptables.
+</Callout>
+
+### Health checks
+
+Some services expose public health check endpoints.
+
+Via proxy (HTTP):
+
+- Index API: <http://index.torrust-demo.com/api/health_check>
+- Tracker API: <http://tracker.torrust-demo.com/api/health_check>
+- Tracker HTTP: <http://tracker.torrust-demo.com/health_check>
+
+Via proxy (HTTPs):
+
+- Index: <https://index.torrust-demo.com/api/health_check>
+- Tracker API: <https://tracker.torrust-demo.com/api/health_check>
+- Tracker HTTPs: <https://tracker.torrust-demo.com/health_check>
+
+Direct access:
+
+- Index API: <http://tracker.torrust-demo.com:3001/health_check>
+- Tracker API: <http://tracker.torrust-demo.com:1212/health_check>
+- Tracker HTTP: <http://tracker.torrust-demo.com:7070/health_check>
+
+<Callout type="info">
+  These endpoints are very useful to test if your installation is OK.
+</Callout>
+
+## Troubleshooting
+
+You might have problems setting up the application. There are some useful things you should know
+in order to be able to address potential problems.
+
+First, it might be useful to enable the debug logging for some services. Both the Index and the Tracker
+have a configuration option `log_level = "info"`. You can change the logging level to `debug` or even `trace`.
+
+Configuration files are located in:
+
+- `./storage/index/etc/index.toml`.
+- `./storage/tracker/etc/tracker.toml`.
+
+If you change the config files you will need to restart the services:
+
+<CodeBlock lang="bash">
+
+```bash
+docker compose restart
+```
+
+</CodeBlock>
+
+You can also check the logs of any service with:
+
+<CodeBlock lang="bash">
+
+```bash
+docker compose logs proxy
+docker compose logs certbot
+docker compose logs index
+docker compose logs index-gui
+docker compose logs tracker
+```
+
+</CodeBlock>
+
+If you change the config files you will need to restart the services.
+
+You can also enable the debug for the Nginx proxy. Edit the file `./storage/proxy/etc/nginx-conf/nginx.conf` and add `error_log` to the server configuration:
+
+<CodeBlock lang="nginx">
+
+```nginx
+server
+{
+    listen 443 ssl http2;
+    listen [::]:443 ssl http2;
+    server_name index.torrust-demo.com;
+
+    error_log /var/log/nginx/error.log debug;
+
+    ...
+}
+```
+
+</CodeBlock>
+
+If your server does not have too much disk space you could run out of disk space.
+
+Docker stores the logs in a separate directory, if you want to truncate the logs you can find them first with:
+
+<CodeBlock lang="bash">
+
+```bash
+sudo : > $(docker inspect --format='{{.LogPath}}' tracker)
+-bash: /var/lib/docker/containers/397484cca9572d98524e4f81095bb27f90c349306c39bc517afe5bcb3a6d7f5e/397484cca9572d98524e4f81095bb27f90c349306c39bc517afe5bcb3a6d7f5e-json.log: Permission denied
+```
+
+</CodeBlock>
+
+And then truncate the file with:
+
+<CodeBlock lang="bash">
+
+```bash
+sudo truncate -s 0 /var/lib/docker/containers/397484cca9572d98524e4f81095bb27f90c349306c39bc517afe5bcb3a6d7f5e/397484cca9572d98524e4f81095bb27f90c349306c39bc517afe5bcb3a6d7f5e-json.log
+```
+
+</CodeBlock>
+
+The docker compose configuration sets a limit on the number of log files and their size.
+
+Finally, if you need some URL to test the HTTP tracker you can use these ones:
+
+- Announce request: <https://tracker.torrust-demo.com/announce?info_hash=%44%3C%76%02%B4%FD%E8%3D%11%54%D6%D9%DA%48%80%84%18%B1%81%B6&peer_addr=2.137.87.41&downloaded=0&uploaded=0&peer_id=-qB00000000000000001&port=17548&left=0&event=completed&compact=0>
+- Scrape request: <https://tracker.torrust-demo.com/scrape?info_hash=%44%3C%76%02%B4%FD%E8%3D%11%54%D6%D9%DA%48%80%84%18%B1%81%B6>
+
+The infohash used is `443C7602B4FDE83D1154D6D9DA48808418B181B6`.
+
+## Maintenance
+
+### Backups
+
+All the data used by the application is in the `storage` folder.
+
+We are using SQLite so the only thing we need to do is to backup the database files.
+
+- Index database: `index/lib/database/sqlite3.db`
+- Tracker database: `tracker/lib/database/sqlite3.db`
+
+We enabled backups for the droplet when we created it. Droplet backups are generated
+once per week. You should setup a better backup policy or use a MySQL service that provides backup.
+An easy way to increase the number of backups would be to mount a volume and periodically backup the files
+you want to backup, for example the database files or the configuration files.
+
+Alternatively, you can use [SnapShooter to backup droplets and volumes](https://docs.digitalocean.com/developer-center/droplets-and-volumes-backups-with-snapshooter/).
+
+How to setup a proper backup policy is out of the scope of this tutorial.
+
+### Monitoring
+
+It's important to know the state of your services. Digital Ocean allow you to set:
+
+- Resource alerts
+- Uptime checks
+
+We have set up both.
+
+With the "resource alerts" you can be notified when the droplet is having trouble with the resources (memory, CPU, disk or bandwidth).
+
+<Image src="/images/posts/deploying-torrust-to-production/digital-ocean-monitoring-resource-alerts.png" alt="Create" />
+
+And "uptime checks" can be used to monitor the state of the services.
+
+<Image src="/images/posts/deploying-torrust-to-production/digital-ocean-monitoring-uptime.png" alt="Create" />
+
+We used the health check endpoints for some services like APIs and the HTTP tracker.
+
+## Cost
+
+- Basic droplet (1GB/1CPU, 25GB SSD Disk, 1000GB transfer): **$6** per month.
+- Weekly droplet backup: **$1.20** per month.
+- Reserved IP: **$5.00** per month.
+- Domain: depends on your provider.
+
+Total cost: **$12.2** per month.
+
+See [Digital Ocean pricing](https://www.digitalocean.com/pricing) for more information.
+
+## Other Considerations
+
+### Adding The Tracker To Public Lists
+
+If you are interested in, you can add your tracker to some tracker lists, for example: <https://newtrackon.com>.
+
+### Sending Emails
+
+We have not enabled email verification. If you enable it you will need to configure the SMTP server in the Index configuration:
+
+<CodeBlock lang="toml">
+
+```toml
+[mail]
+email_verification_enabled = false
+from = "example@email.com"
+reply_to = "noreply@email.com"
+username = ""
+password = ""
+server = "mailcatcher"
+port = 1025
+```
+
+</CodeBlock>
+
+### Docker Image Tags
+
+We have used the `develop` tag for the Docker images. We will update this guide to use version `v3.0` once it's released.
+
+## Links
+
+- [How To Secure a Containerized Node.js Application with Nginx, Let's Encrypt, and Docker Compose](https://www.digitalocean.com/community/tutorials/how-to-secure-a-containerized-node-js-application-with-nginx-let-s-encrypt-and-docker-compose)
+- [Initial Server Setup with Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-22-04)
+- [How to Set Up SSH Keys on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-set-up-ssh-keys-on-ubuntu-22-04)
+- [How To Install and Use Docker on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-22-04)
+- [How To Install and Use Docker Compose on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-compose-on-ubuntu-22-04)
+- [How To Set Up a Firewall with UFW on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-firewall-with-ufw-on-ubuntu-22-04)
+- [How To Install Git on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-install-git-on-ubuntu-22-04)
+- [How To Set Up a Firewall with UFW on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-firewall-with-ufw-on-ubuntu-22-04)
+- [BEP 34 DNS Tracker Preferences](https://www.bittorrent.org/beps/bep_0034.html)
+- <https://letsencrypt.org/>
+- <https://certbot.eff.org/>
+- [UDP Tracker with Nginx proxy](https://github.com/torrust/torrust-tracker/issues/11)
+- [Digital Ocean - Backups Features](https://docs.digitalocean.com/products/images/backups/details/features/).
+- [Droplets and Volumes Backups with SnapShooter](https://docs.digitalocean.com/developer-center/droplets-and-volumes-backups-with-snapshooter/)
+- [Digital Ocean pricing](https://www.digitalocean.com/pricing)
+
+## Conclusion
+
+With containerization, having a production ready Index and Tracker with Torrust is very easy. Containerization allows you to install the application in many different hosting providers with no effort.
+
+It also allows you to keep your production environment up to date, because it's also possible to easily update the docker images.
+
+And finally, you can also scale up your production environment as long as the demand increases. For example, just increasing the droplet size.
+
+We hope you find this guide useful. Let us know what you think about it!
+
+- Do you think the process is to complex?
+- Do you think the process could be improved or simplified?
+- Is there something missing you want to know about?
+
+If you see something wrong or you want to contribute by:
+
+- Adding new sections.
+- Fixing typos.
+- Making it clearer.
+- Adding links.
+- Or whatever you think that could be interesting to have,
+
+please open an [issue](https://github.com/torrust/torrust-website/issues) or a [PR](https://github.com/torrust/torrust-website/pulls).
+
+If you have any questions or issues please open an issue in the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index: <https://github.com/torrust/torrust-index-backend/issues>
+- Torrust Website: <https://github.com/torrust/torrust-index-frontend/issues>
+- Torrust Compose: <https://github.com/torrust/torrust-compose>
+- Containerizing Rust Applications Examples: <https://github.com/torrust/containerizing-rust-apps-examples>
+
+We very welcome any contributions to the projects or [this article](https://github.com/torrust/torrust-website/issues).
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/hash2torrent-retrieve-torrent-files-effortlessly/+page.md b/src/routes/v2/(blog-article)/hash2torrent-retrieve-torrent-files-effortlessly/+page.md
new file mode 100644
index 0000000..aee116e
--- /dev/null
+++ b/src/routes/v2/(blog-article)/hash2torrent-retrieve-torrent-files-effortlessly/+page.md
@@ -0,0 +1,151 @@
+---
+title: Hash2Torrent - Retrieve Torrent Files Effortlessly!
+slug: hash2torrent-retrieve-torrent-files-effortlessly
+coverImage: /images/posts/hash2torrent-retrieve-torrent-files-effortlessly/hash2torrent-screenshot.png
+date: 2024-09-05T10:00:00.000Z
+updated: 2024-09-05T10:00:00.000Z
+excerpt: Discover Hash2Torrent, a new tool to fetch torrent files (metainfo files) directly from their infohash! Simplify your torrent management and integrations with our easy-to-use service.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Service
+  - Demo
+  - Metainfo
+  - Metadata
+  - Sample
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+
+<PostTable>
+
+## Table of contents
+
+- [Why this tool](#why-this-tool)
+- [Implementation](#implementation)
+- [Alternative Methods](#alternative-methods)
+- [Benefits of Using Hash2Torrent](#benefits-of-using-hash2torrent)
+- [Conclusion](#conclusion)
+- [Links](#links)
+- [Acknowledgments](#acknowledgments)
+
+</PostTable>
+
+<PostBody>
+
+Hello, Torrust community!
+
+We are thrilled to introduce our newest project: [Hash2Torrent](https://hash2torrent.com/), a web service that allows you to easily retrieve torrent files using only their infohash (version 1).
+
+Hash2Torrent is designed to make torrent management more accessible and user-friendly, without the need to install a BitTorrent client.
+
+<Callout type="success">
+
+https://hash2torrent.com
+
+</Callout>
+
+## Why this tool
+
+In our quest to find a straightforward tool that allows users to download torrent files directly from an infohash, we discovered that there wasn't a simple, reliable service available. We set out to change that by creating Hash2Torrent — a service that fills this gap. With Hash2Torrent, you can now quickly download torrent files by simply entering the infohash on our website ([hash2torrent.com](https://hash2torrent.com/)) or using a direct URL format:
+
+<Callout type="info">
+
+```text
+https://hash2torrent.com/{info-hash}
+```
+
+</Callout>
+
+For example: <https://hash2torrent.com/443c7602b4fde83d1154d6d9da48808418b181b6>.
+
+<Callout type="warning">
+
+The service does NOT download the contents described in the torrent file. It only ask other peers for the torrent file, also called metainfo file. Besides, the file (called metadata in BEP 9) includes only the info dictionary because is the only part covered by the info-hash. See [BEP 9](https://www.bittorrent.org/beps/bep_0009.html) for more information.
+
+</Callout>
+
+## Implementation
+
+The project is a thin API wrapper that uses the Rust BitTorrent client [rqbit](https://github.com/ikatson/rqbit). rqbit has an option to add a torrent to the client in `list-only` mode, meaning the torrent is not downloaded, but only listed in the client. When you add a new torrent from a magnet-link, the client automatically gets the torrent file from other peers if it's available.
+
+The API generates a magnet-link for the info-hash and adds that magnet-link to the client in `list-only` mode. The clients returns the torrent file.
+
+<Callout type="warning">
+
+For the time being, the service API only returns a direct (not user-friendly) timeout (408) if the client behind the service can't find any peer having that torrent.
+
+</Callout>
+
+## Alternative Methods
+
+Traditionally, if you wanted to retrieve a torrent file using its infohash, you would have to:
+
+- Open a BitTorrent client that supports DHT (Distributed Hash Table).
+- Add the infohash as a magnet link.
+- Wait for the client to find peers that have the torrent file.
+
+While this method works, it can be cumbersome and is not ideal if you're looking for a lightweight solution or need to automate the process for integration into other services.
+
+<Callout type="info">
+
+**NOTICE:** You need the DHT to find other peers having the torrent. In the future we could also also user to introduce a magnet-link that may contain a list of trackers. In that case, the client could use those tracker to find peers.
+
+</Callout>
+
+## Benefits of Using Hash2Torrent
+
+Hash2Torrent is all about simplicity and ease of integration:
+
+- **User-Friendly Interface:** Just like a Google search, simply type the infohash into our form, click download, and if peers are available, the torrent file will be downloaded within seconds.
+- **Direct URL Access:** Use our direct URL format to fetch torrent files programmatically, making it ideal for integration with other tools and services.
+- **Efficiency:** No need to deal with BitTorrent clients or complex setups. Hash2Torrent is the simplest way to get a torrent file from an infohash. We have also added a torrents cache so it will be even faster if the torrent is already cached.
+- **Contribution to the Ecosystem:** By providing this service, we aim to empower the community with more tools that enhance the overall BitTorrent experience.
+
+<Callout type="info">
+
+Try it out! Visit Hash2Torrent ([hash2torrent.com](https://hash2torrent.com/)) and give it a try with your favorite torrents' infohashes. We are eager to hear your feedback and suggestions.
+
+</Callout>
+
+## Conclusion
+
+We built Hash2Torrent to make torrent retrieval from infohashes as easy as possible. Whether you're a casual user who needs the occasional torrent file or a developer looking to integrate torrent retrieval into your application, Hash2Torrent is here to help.
+
+This project is just one of the many ways we plan to contribute to the BitTorrent ecosystem by providing practical, user-friendly tools. We believe in building a more accessible torrenting experience for everyone, and Hash2Torrent is a significant step in that direction. We are excited to continue innovating and supporting the community with more tools like this!
+
+Happy torrenting!
+
+## Links
+
+- [The live demo](https://hash2torrent.com/).
+- [Github repo](https://github.com/torrust/torrust-hash2torrent).
+
+## Acknowledgments
+
+A massive thank you to all contributors who made this project possible, especially those involved in developing the Rust-based BitTorrent client that powers Hash2Torrent, specially to [Igor Katson](https://github.com/ikatson) whose work underpins Hash2Torrent. Their dedication and contributions have been instrumental in bringing this service to life.
+
+If you have any questions or issues regarding this post, please [open an issue](https://github.com/torrust/torrust-website/issues/new).
+
+For any other questions or issues related to Torrust repositories, please open an issue on the corresponding repository:
+
+- Torrust Hash2Torrent: <https://github.com/torrust/torrust-hash2torrent/issues>
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index Backend: <https://github.com/torrust/torrust-index/issues>
+- Torrust Index Frontend: <https://github.com/torrust/torrust-index-gui/issues>
+
+We very welcome any contributions to the project!
+
+</PostBody>
+
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/how-to-contribute-to-this-site/+page.md b/src/routes/v2/(blog-article)/how-to-contribute-to-this-site/+page.md
new file mode 100644
index 0000000..9aa6af8
--- /dev/null
+++ b/src/routes/v2/(blog-article)/how-to-contribute-to-this-site/+page.md
@@ -0,0 +1,89 @@
+---
+title: How To Contribute To This Site
+slug: how-to-contribute-to-this-site
+coverImage: /images/posts/sample-post.jpg
+date: 2023-04-22T21:55:15.361Z
+updated:
+excerpt: How to manage existing blog posts and create new ones on this site.
+tags:
+  - Documentation
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of Contents
+
+- [Processing](#processing)
+- [Creating a new post](#creating-a-new-post)
+- [Managing blog posts](#managing-blog-posts)
+- [RSS](#rss)
+
+</PostTable>
+
+<PostBody>
+
+All blog posts are located inside the `src/routes/(blog-article)` folder. Each folder inside it represents a blog post, and each folder has a `+page.md` file, which is the file that contains the post's content.
+
+This way, the URL for each blog post is generated with the folder's name. For example, the folder `src/routes/(blog-article)/how-blog-posts-work` will generate the URL `https://mysite.com/how-blog-posts-work`.
+
+All posts are Markdown files, which means you can use the [Markdown syntax](https://www.markdownguide.org/basic-syntax) in them, and it will work out of the box. However, since this projects uses [MDsveX](https://mdsvex.pngwn.io/) to parse Markdown, you can also use Svelte components inside them! This means that the components used in other pages can also be used in blog posts.
+
+<Callout type="info">
+  This is a Svelte component inside a Markdown file!
+</Callout>
+
+## Processing
+
+Besides the blog post page itself, the blog posts can be displayed in other places, such as the `/blog` page, which lists all blog posts, and the `<RecentPosts>` component, used in the home page.
+
+To be able to do that, posts are processed in the `src/lib/data/blog-posts/index.ts` file. That file imports the blog post files and processes them, so we're able to use some of the post's metadata to list them. For example, we get the post's title, cover image, and calculate the reading time based on its content, so that information is displayed in the blog post cards in the `/blog` page.
+
+There is also some basic logic to get related posts based on a post's tags. The logic should be straightforward enough to modify it to your needs.
+
+## Creating a new post
+
+To create a new post, create a new folder inside the `src/routes/(blog-article)` folder, and inside it, create a `+page.md` file. The folder name will be used as the post's URL slug, so make sure it's a valid URL slug.
+
+Inside the `+page.md` file, you must start with the front matter, which is a YAML-like syntax that is used to define metadata for the post. The front matter must be the first thing in the file, and must be separated from the rest of the content by three dashes (`---`). An example of a front matter is:
+
+<CodeBlock lang="markdown">
+
+```md
+---
+slug: my-new-blog-post
+title: My New Blog Post
+date: 2023-04-22T20:45:25.350Z
+excerpt: A short description of the post
+coverImage: /images/posts/cover-image.jpg
+tags:
+  - Example
+---
+```
+
+</CodeBlock>
+
+## Managing blog posts
+
+I highly recommend the [Front Matter VS Code extension](https://frontmatter.codes/) to manage blog posts. It gives you a nice CMS-like UI to manage the front matter of all blog posts, as well as a preview of their content. It is, of course, optional, and you can manage everything directly in the Markdown files if you prefer.
+
+<Image fullBleed src="/images/posts/frontmatter-preview-dashboard.png" alt="Screenshot of the Front Matter VS Code extension, showing the dashboard with all posts" />
+
+<Image fullBleed src="/images/posts/frontmatter-preview-edit.png" alt="Screenshot of the Front Matter VS Code extension, showing the post editing UI" />
+
+## RSS
+
+This template automatically generates a RSS feed of your blog posts. It is generated in the `src/routes/rss.xml/+server.ts` file, and it is available at the `/rss.xml` URL.
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/how-to-run-a-local-demo/+page.md b/src/routes/v2/(blog-article)/how-to-run-a-local-demo/+page.md
new file mode 100644
index 0000000..9279a32
--- /dev/null
+++ b/src/routes/v2/(blog-article)/how-to-run-a-local-demo/+page.md
@@ -0,0 +1,159 @@
+---
+title: How To Run A Local Demo
+slug: how-to-run-a-local-demo
+coverImage: /images/posts/mandelbrot-set-periods-torrent-screenshot.png
+date: 2023-07-11T15:28:28.769Z
+updated: 2023-07-11T15:28:29.783Z
+excerpt: You can easily run the Torrust Index demo on your computer easily with Git and Docker.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Demo
+  - Tutorial
+  - Guide
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of Contents
+
+- [Requirements](#requirements)
+- [Running the demo](#running-the-demo)
+- [Application Setup](#application-setup)
+- [Advanced Setup](#advanced-setup)
+- [Conclusion](#conclusion)
+
+</PostTable>
+
+<PostBody>
+
+If you want to try the Torrust Index **demo** on your computer, you can easily run it with Git and Docker. This guide will explain how to setup the demo on your own computer in **a few seconds**.
+
+## Requirements
+
+You are going to need the following tools:
+
+- Git
+- Docker
+
+At the time of writing, we are using Git version `2.39.2` and Docker version `26.1.3`, but it should work with any recent version.
+
+By default, the demo uses SQLite3 as database driver, but you can also use MySQL. If you want to use SQLite3, you do not need to install anything else. If you want to take a look at the internal database structure or data, you can install [DB Browser for SQLite](https://sqlitebrowser.org/).
+
+<Callout type="info">
+  Although we use some small bash scripts, you can run the demo on different operating systems by executing the docker-compose command manually. We have tested it on Linux.
+</Callout>
+
+## Running the demo
+
+We are going to use a temporary directory to run the demo. You can install the demo with the following commands:
+
+<CodeBlock lang="terminal">
+
+```s
+mkdir -p /tmp/torrust \\
+  && cd /tmp/torrust \\
+  && git clone git@github.com:torrust/torrust-compose.git \\
+  && cd torrust-compose/demo \\
+  && ./bin/install.sh
+```
+
+</CodeBlock>
+
+To start the application:
+
+<CodeBlock lang="terminal">
+
+```s
+./bin/start.sh
+```
+
+</CodeBlock>
+
+To stop the application:
+
+<CodeBlock lang="terminal">
+
+```s
+./bin/stop.sh
+```
+
+</CodeBlock>
+
+After starting the demo you can check that all container are running with the following command:
+
+<CodeBlock lang="output">
+
+```s
+$ docker ps
+CONTAINER ID   IMAGE                       COMMAND                  CREATED         STATUS                            PORTS                                                                                                      NAMES
+e380a435eede   torrust/index-gui:develop   "/usr/local/bin/entrypoint.sh"   4 seconds ago   Up 3 seconds (health: starting)   0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, 0.0.0.0:24678->24678/tcp, :::24678->24678/tcp                   torrust-index-gui-1
+db8f7c679b66   torrust/index:develop       "/usr/local/bin/entrypoint.sh"   5 seconds ago   Up 3 seconds (health: starting)   0.0.0.0:3001->3001/tcp, :::3001->3001/tcp                                                                  torrust-index-1
+820720c37d80   torrust/tracker:develop     "/usr/local/bin/entrypoint.sh"   5 seconds ago   Up 4 seconds (health: starting)   1313/tcp, 0.0.0.0:1212->1212/tcp, :::1212->1212/tcp, 7070/tcp, 0.0.0.0:6969->6969/udp, :::6969->6969/udp   torrust-tracker-1
+a9668e78f3cc   mysql:8.0                   "docker-entrypoint.s…"   5 seconds ago   Up 4 seconds (health: starting)   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp                                                       torrust-mysql-1
+c10ad938b283   dockage/mailcatcher:0.8.2   "entrypoint mailcatcher"   5 seconds ago   Up 4 seconds                      0.0.0.0:1025->1025/tcp, :::1025->1025/tcp, 0.0.0.0:1080->1080/tcp, :::1080->1080/tcp                       torrust-mailcatcher-1
+
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  IMPORTANT! We use the latest commit from the develop branches of the Torrust repositories. If you want to use the latest stable version, you can change the tag for the docker images in the `docker-compose.yml` file.
+</Callout>
+
+Once the demo is running, you go to <http://localhost:3000/> to start using it.
+
+## Application Setup
+
+The application has some public pages like the torrent list or torrent details pages. But other pages require authentication. To access those pages you need to create an account. You can do it from the signup page:
+
+<http://localhost:3000/signup>
+
+<Callout type="info">
+  The first user registered will be the <code>admin</code> user. The application only has one admin user.
+</Callout>
+
+The application is very easy to use but you can find comprehensive documentation in the following links:
+
+- [Torrust Index GUI User's Guide](https://torrust.github.io/torrust-index-gui-user-guide/)
+- [Torrust Index GUI](https://github.com/torrust/torrust-index-gui/blob/develop/docs/index.md)
+- [Torrust Index](https://docs.rs/torrust-index>)
+- [Torrust Tracker](https://docs.rs/torrust-tracker)
+
+## Advanced Setup
+
+You can modify the configuration of the demo to use different ports, database drivers, etcetera. But we are going to use the default configuration in this guide.
+
+If you want to change the configuration for the Tracker or the Index Backend, you can do it by modifying the `config-tracker.local.toml` or `config-index.local.toml` files and stopping (`./bin/stop.sh`) and starting (`./bin/start.sh`) the docker containers again.
+
+Refer to the documentation of the corresponding application to know more about the configuration options:
+
+- [Torrust Tracker](https://github.com/torrust/torrust-tracker)
+- [Torrust Index](https://github.com/torrust/torrust-index)
+- [Torrust Index GUI](https://github.com/torrust/torrust-index-gui)
+
+## Conclusion
+
+That's it. Enjoy the demo! We will publish a new blog post soon explaining how to use the demo for basics tasks like uploading a torrent, adding categories or tags, etcetera.
+
+If you have any questions or issues please open an issue on the corresponding repository:
+
+- [Torrust Tracker](https://github.com/torrust/torrust-tracker/issues)
+- [Torrust Index](https://github.com/torrust/torrust-index/issues)
+- [Torrust Index GUI](https://github.com/torrust/torrust-index-gui/issues)
+
+We very welcome any contributions to the project!
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/how-to-setup-the-development-environment/+page.md b/src/routes/v2/(blog-article)/how-to-setup-the-development-environment/+page.md
new file mode 100644
index 0000000..a4ba679
--- /dev/null
+++ b/src/routes/v2/(blog-article)/how-to-setup-the-development-environment/+page.md
@@ -0,0 +1,409 @@
+---
+title: How To Setup The Dev Env
+slug: how-to-setup-the-development-environment
+coverImage: /images/posts/development-environment.png
+date: 2023-07-11T12:29:04.295Z
+updated: 2024-04-24T12:32:00.783Z
+excerpt: If you want to contribute to the Torrust Index, this article explains how to setup a development environment with the latest versions for all services.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Documentation
+  - Tutorial
+  - Guide
+  - Development
+  - Setup
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Common Dependencies](#common-dependencies)
+- [Set Up the Torrust Tracker](#set-up-the-torrust-tracker)
+- [Set Up the Torrust Index](#set-up-the-torrust-index)
+- [Set Up the Torrust Index GUI](#set-up-the-torrust-index-gui)
+- [Application Setup](#application-setup)
+- [Development tools](#development-tools)
+- [Conclusion](#conclusion)
+
+</PostTable>
+
+<PostBody>
+
+## Introduction
+
+Before explaining how to setup the development environment, it's important to understand how the Torrust Index works. The Torrust Index is composed of multiple services, each one with its own codebase and repository. The services are:
+
+- A [BitTorrent Tracker](https://github.com/torrust/torrust-tracker), which is responsible for tracking the torrents and providing the peers to the clients.
+- The [Index](https://github.com/torrust/torrust-index), which is a REST API that provides the data to the frontend.
+- And the [Index GUI](https://github.com/torrust/torrust-index-gui), which is a webapp that displays the data to the user.
+
+<Image src="/images/posts/torrust-architecture.png" alt="Torrust Architecture" />
+
+You do not need to setup all services to contribute to the Torrust Index, but in this article we will explain how to setup the full development environment, which includes all services. Sometimes you might want to contribute with a full feature that involves multiple services, so it's useful to have the full development environment setup.
+
+Setting up the development environment requires to setup the three main services.
+
+First, we need to create the folder (in this example, a temp folder) where we will store the repositories of our services.
+
+<CodeBlock lang="terminal">
+
+```bash
+cd /tmp/
+mkdir -p torrust
+cd torrust
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  This guide uses bash commands and it has been tested on Ubuntu Ubuntu 23.04. You should not encounter any problem if you are using a different Linux distribution, but there are some reported issues with Windows compilation for the Tracker. The installation scripts are very simple, so you can easily adapt them to your system or run the commands manually.
+</Callout>
+
+## Common Dependencies
+
+If you are using SQLite3 as database driver for the Tracker or the Backend, you will need to install the following dependency:
+
+<CodeBlock lang="terminal">
+
+```bash
+sudo apt-get install libsqlite3-dev
+```
+
+</CodeBlock>
+
+## Set Up the Torrust Tracker
+
+This tutorial is tested with this Rust version:
+
+- rustc 1.80.0-nightly (9cdfe285c 2024-05-22)
+
+Since we are using the openssl crate with the [vendored](https://docs.rs/openssl/latest/openssl/#vendored) feature, enabled, you will need to install the following dependencies:
+
+<CodeBlock lang="terminal">
+
+```bash
+sudo apt-get install pkg-config libssl-dev make
+```
+
+</CodeBlock>
+
+Now, we will build the tracker and create the storage folders where persistent data like databases will be stored:
+
+<CodeBlock lang="terminal">
+
+```terminal
+git clone https://github.com/torrust/torrust-tracker.git \\
+  && cd torrust-tracker \\
+  && cargo build \\
+  && mkdir -p ./storage/tracker/lib/database \\
+  && mkdir -p ./storage/tracker/lib/tls \\
+  && mkdir -p ./storage/tracker/etc
+```
+
+</CodeBlock>
+
+You can run the Tracker with the following command:
+
+<CodeBlock lang="terminal">
+
+```bash
+cargo run
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  NOTICE: You do not need to change the default values for development.
+</Callout>
+
+After running the Tracker with `cargo run` you should see the following output:
+
+<CodeBlock lang="output">
+
+```s
+Finished `dev` profile [optimized + debuginfo] target(s) in 0.09s
+     Running `target/debug/torrust-tracker`
+Loading configuration from default configuration file: `./share/default/config/tracker.development.sqlite3.toml` ...
+2024-05-27T11:39:21.332802857+01:00 [torrust_tracker::bootstrap::logging][INFO] logging initialized.
+2024-05-27T11:39:21.333426924+01:00 [UDP TRACKER][INFO] Starting on: udp://0.0.0.0:6969
+2024-05-27T11:39:21.333462384+01:00 [torrust_tracker::bootstrap::jobs][INFO] TLS not enabled
+2024-05-27T11:39:21.333491694+01:00 [HTTP TRACKER][INFO] Starting on: http://0.0.0.0:7070
+2024-05-27T11:39:21.333599174+01:00 [HTTP TRACKER][INFO] Started on: http://0.0.0.0:7070
+2024-05-27T11:39:21.333615604+01:00 [torrust_tracker::bootstrap::jobs][INFO] TLS not enabled
+2024-05-27T11:39:21.333814923+01:00 [API][INFO] Starting on http://127.0.0.1:1212
+2024-05-27T11:39:21.333839143+01:00 [API][INFO] Started on http://127.0.0.1:1212
+2024-05-27T11:39:21.333883712+01:00 [HEALTH CHECK API][INFO] Starting on: http://127.0.0.1:1313
+2024-05-27T11:39:21.333948472+01:00 [HEALTH CHECK API][INFO] Started on: http://127.0.0.1:1313
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  IMPORTANT: Every time you change the configuration you need to restart the service.
+</Callout>
+
+By default, if you don't specify any `Config.toml` file, the application will use this:
+
+<CodeBlock lang="output">
+
+```s
+Loading default configuration file: `./share/default/config/tracker.development.sqlite3.toml` ...
+```
+
+</CodeBlock >
+
+You can't change that file because it's a template included in the repo. If you want to set your custom configuration, you can either:
+
+1. Use a different path for the config file.
+2. Inject the configuration with an environment variable.
+
+## Custom config file
+
+First, copy the template file to the storage folder:
+
+<CodeBlock lang="terminal">
+
+```bash
+cp share/default/config/tracker.development.sqlite3.toml storage/tracker/etc/tracker.toml
+```
+
+</CodeBlock>
+
+Then, you can change any value and finally run the tracker with:
+
+<CodeBlock lang="terminal">
+
+```bash
+TORRUST_TRACKER_CONFIG_TOML_PATH="./storage/tracker/etc/tracker.toml" cargo run
+```
+
+</CodeBlock>
+
+That would give you this output:
+
+<CodeBlock lang="output">
+
+```s
+TORRUST_TRACKER_CONFIG_TOML_PATH="./storage/tracker/etc/tracker.toml" cargo run
+    Finished `dev` profile [optimized + debuginfo] target(s) in 0.09s
+     Running `target/debug/torrust-tracker`
+Loading configuration from file: `./storage/tracker/etc/tracker.toml` ...
+2024-05-27T12:52:00.364641064+01:00 [torrust_tracker::bootstrap::logging][INFO] logging initialized.
+2024-05-27T12:52:00.365277963+01:00 [UDP TRACKER][INFO] Starting on: udp://0.0.0.0:6969
+2024-05-27T12:52:00.365309093+01:00 [torrust_tracker::bootstrap::jobs][INFO] TLS not enabled
+2024-05-27T12:52:00.365355473+01:00 [HTTP TRACKER][INFO] Starting on: http://0.0.0.0:7070
+2024-05-27T12:52:00.365496743+01:00 [HTTP TRACKER][INFO] Started on: http://0.0.0.0:7070
+2024-05-27T12:52:00.365504943+01:00 [torrust_tracker::bootstrap::jobs][INFO] TLS not enabled
+2024-05-27T12:52:00.365596502+01:00 [API][INFO] Starting on http://127.0.0.1:1212
+2024-05-27T12:52:00.365599702+01:00 [API][INFO] Started on http://127.0.0.1:1212
+2024-05-27T12:52:00.365616862+01:00 [HEALTH CHECK API][INFO] Starting on: http://127.0.0.1:1313
+2024-05-27T12:52:00.365711472+01:00 [HEALTH CHECK API][INFO] Started on: http://127.0.0.1:1313
+```
+
+</CodeBlock>
+
+## Inject the configuration with an environment variable
+
+You can also inject the configuration with:
+
+<CodeBlock lang="terminal">
+
+```bash
+TORRUST_TRACKER_CONFIG_TOML=`cat share/default/config/tracker.development.sqlite3.toml` cargo run
+```
+
+</CodeBlock>
+
+<Callout type="info">
+  NOTICE: We load the whole file into the env var. This is not useful for development, but it's a different way to inject the configuration. It's used when running the tracker with docker.
+</Callout>
+
+The response should be like this:
+
+<CodeBlock lang="json">
+
+```json
+{
+	"torrents": 0,
+	"seeders": 0,
+	"completed": 0,
+	"leechers": 0,
+	"tcp4_connections_handled": 0,
+	"tcp4_announces_handled": 0,
+	"tcp4_scrapes_handled": 0,
+	"tcp6_connections_handled": 0,
+	"tcp6_announces_handled": 0,
+	"tcp6_scrapes_handled": 0,
+	"udp4_connections_handled": 0,
+	"udp4_announces_handled": 0,
+	"udp4_scrapes_handled": 0,
+	"udp6_connections_handled": 0,
+	"udp6_announces_handled": 0,
+	"udp6_scrapes_handled": 0
+}
+```
+
+</CodeBlock>
+
+For more details about the Torrust Tracker, check the [Tracker documentation](https://docs.rs/torrust-tracker/).
+
+## Set Up the Torrust Index
+
+This tutorial has been tested with this Rust version:
+
+- rustc 1.80.0-nightly (9cdfe285c 2024-05-22)
+
+To run the tests you will also need to install a command line tool to handle torrent files called [imdl](https://github.com/casey/intermodal). You can install it with the following command:
+
+<CodeBlock lang="terminal">
+
+```bash
+cargo install imdl
+```
+
+</CodeBlock>
+
+You will also need to install a tool for database migrations if you are going to make changes to the database schema. We are using [SQLx](https://github.com/launchbadge/sqlx). You can install it with the following command:
+
+<CodeBlock lang="terminal">
+
+```bash
+cargo install sqlx-cli
+```
+
+</CodeBlock>
+
+We will now clone the `torrust-index` repository:
+
+<CodeBlock lang="terminal">
+
+```terminal
+  git clone https://github.com/torrust/torrust-index.git \\
+  && cd torrust-index \\
+  && cargo build \\
+  && mkdir -p ./storage/index/lib/database \\
+  && mkdir -p ./storage/index/lib/tls
+```
+
+</CodeBlock>
+
+You can run the Torrust Index with the following commands:
+
+<CodeBlock lang="terminal">
+
+```bash
+TORRUST_INDEX_API_CORS_PERMISSIVE=true cargo run
+```
+
+</CodeBlock>
+
+As you can see we are using the environment variable `TORRUST_IDX_BACK_CORS_PERMISSIVE` to enable a permissive CORS policy. The default port for the Backend is `3001` and for the web server serving the frontend application is `3000`. Since they are different ports, we need to tell the backend to allow requests from a different port so that the frontend can make request to the API. To know more about CORS, check the [Mozilla CORS documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS).
+
+After running the Index with `TORRUST_INDEX_API_CORS_PERMISSIVE=true cargo run` you should see the following output:
+
+<CodeBlock lang="output">
+
+```s
+Loading configuration from default configuration file: `./share/default/config/index.development.sqlite3.toml` ...
+2024-05-27T12:56:25.300980998+01:00 [torrust_index::bootstrap::logging][INFO] logging initialized.
+2024-05-27T12:56:25.425949219+01:00 [torrust_index::web::api::server][INFO] TLS not enabled
+2024-05-27T12:56:25.425976429+01:00 [torrust_index::console::cronjobs::tracker_statistics_importer][INFO] Tracker statistics importer launcher started
+2024-05-27T12:56:25.426077258+01:00 [torrust_index::console::cronjobs::tracker_statistics_importer][INFO] Tracker statistics importer cronjob starting ...
+2024-05-27T12:56:25.426233288+01:00 [torrust_index::web::api::server][INFO] Starting API server with net config: 0.0.0.0:3001 ...
+2024-05-27T12:56:25.426290848+01:00 [torrust_index::console::cronjobs::tracker_statistics_importer][INFO] Tracker statistics importer API server listening on http://127.0.0.1:3002
+2024-05-27T12:56:25.426250898+01:00 [torrust_index::console::cronjobs::tracker_statistics_importer][INFO] Running tracker statistics importer every 2000 milliseconds ...
+2024-05-27T12:56:25.427603675+01:00 [torrust_index::web::api::server][INFO] API server listening on http://0.0.0.0:3001
+```
+
+</CodeBlock>
+
+You should be able to load the API entrypoint on <http://0.0.0.0:3001/>
+
+<Image src="/images/posts/torrust-backend-api-entrypoint-response-screenshot.png" alt="Screenshot of Torrust Backend API entrypoint response" />
+
+For more details about the Torrust Index Backend, check the [Index Backend documentation](https://docs.rs/torrust-index/).
+
+## Set Up the Torrust Index GUI
+
+At the time of writing, the Index GUI requires:
+
+- Node: `^v20.12.2`
+
+The frontend is a [Nuxt](https://nuxt.com/) application.
+
+The last repository we need to clone is the `torrust-index-gui` repository . Remember to install Node.js and we need to be in the torrust folder to clone the repository.
+
+<CodeBlock lang="terminal">
+
+```terminal
+git clone https://github.com/torrust/torrust-index-gui.git \\
+  && cd torrust-index-gui \\
+  && npm install \\
+  && cp .env.local .env \\
+  && npm run dev
+```
+
+</CodeBlock>
+
+You should see the following output:
+
+<Image src="/images/posts/how-to-setup-the-development-environment/npm-run-dev-output.png" alt="Screenshot of Torrust Index GUI running from the terminal" />
+
+Go to <http://localhost:3000/torrents> and you should see the torrent list page page:
+
+<Image src="/images/posts/how-to-setup-the-development-environment/index-gui-after-fresh-install.png" alt="Screenshot of torrent list page on the browser" />
+
+For more details about the Torrust Index GUI, check the [Index GUI documentation](https://github.com/torrust/torrust-index-gui).
+
+## Application Setup
+
+There are some public pages like the torrent list or torrent details pages. But there are some pages that require authentication like the admin pages or the pages for uploading or editing torrents.
+
+To access those pages you need to create an account. You can do it from the signup page:
+
+<http://localhost:3000/signup>
+
+<Callout type="info">
+  The first user created will be the <code>admin</code> user.
+</Callout>
+
+## Development tools
+
+We found some tools very useful to develop the Torrust Tracker and Index. We hope you find them useful too.
+
+- DB Browser for SQLite: <https://sqlitebrowser.org/>
+- BitTorrent client: qBittorrent <https://www.qbittorrent.org/>
+- Torrent file editor: imdl <https://github.com/casey/intermodal>
+- DaisyUI component library: <https://daisyui.com/components/>
+
+## Conclusion
+
+As you can see, the Torrust Tracker and Index are very easy to set up. We hope you find this guide useful. You might have problems:
+
+- Setting up some of the projects on Windows. [We are working on it](https://github.com/torrust/torrust-tracker/issues/325).
+- Or with some missing system dependencies.
+
+If you have any questions or issues please open an issue on the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index: <https://github.com/torrust/torrust-index/issues>
+- Torrust Index GUI: <https://github.com/torrust/torrust-index-gui/issues>
+
+We very welcome any contributions to the project!
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/introducing-the-new-sample-torrent-migration-tool/+page.md b/src/routes/v2/(blog-article)/introducing-the-new-sample-torrent-migration-tool/+page.md
new file mode 100644
index 0000000..045466e
--- /dev/null
+++ b/src/routes/v2/(blog-article)/introducing-the-new-sample-torrent-migration-tool/+page.md
@@ -0,0 +1,144 @@
+---
+title: Introducing the New Sample Torrent Migration Tool
+slug: introducing-the-new-sample-torrent-migration-tool
+coverImage: /images/posts/pexels-david-dibert-7177008.jpg
+date: 2023-09-04T13:24:27.241Z
+updated: 2023-09-04T13:24:27.241Z
+excerpt: Looking to migrate to the Torrust Index? Dive into our Torrents Importer Sample to seamlessly transfer your torrents to Torrust.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Migration Tool
+  - Sample
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+Photo by David Dibert: <https://www.pexels.com/photo/a-flock-of-geese-flying-7177008/>.
+
+Hello, Torrust community!
+
+We're always looking for ways to enhance your experience with Torrust, and today, we're excited to unveil our latest addition: [A sample migration tool written in Rust](https://github.com/torrust/torrents-importer-sample), specifically designed for those looking to seamlessly import torrents from other sources into our [Torrust Index](https://github.com/torrust/torrust-index-backend)!
+
+<PostContainer>
+<PostTable>
+
+## Table of contents
+
+- [Why this tool?](#why-this-tool)
+- [Capabilities](#capabilities)
+- [Conclusion](#conclusion)
+- [Links](#links)
+- [Acknowledgments](#acknowledgments)
+
+</PostTable>
+
+<PostBody>
+
+## Why this tool?
+
+Many in our community have asked us for an efficient method to migrate torrents from their current Index/Trackers to Torrust. Recognizing this need, we took it upon ourselves to develop a solution that would make this process as hassle-free as possible.
+
+On the other hand, we have been doing an intensive testing of the Torrust Index Backend. We wanted to test the backend with a large set of real torrents. We found the site <https://academictorrents.com/> which has thousands of torrents and they kindly make them public available.
+
+We decided to create a tool that would allow us to import torrents from this site into our Torrust Index. This tool is a sample project that we are sharing with the community. We hope that it will be useful for those who want to migrate their torrents to Torrust.
+
+The example repo is <https://github.com/torrust/torrents-importer-sample>
+
+## Capabilities
+
+The migration tool sample offers a straightforward way to:
+
+- Fetch Torrents from XML Lists: The tool takes torrents from a list in an XML file, ensuring you don’t have to manually pick and transfer torrents one by one.
+- Download Torrents from Other Sites: No more downloading and re-uploading! Our tool will directly fetch the torrents for you.
+- Upload to Torrust: With the help of the Torrust Index REST API, the torrents are then uploaded into our software, ready for classification and use.
+
+While our initial test run has been on an index containing academic torrents, the tool is versatile enough to handle a variety of sources. The underlying principles remain the same.
+
+<Callout type="info">
+
+**Disclaimer**: This sample project is not intended to be a production-ready tool. It is a sample project that we are sharing with the community. We hope that it will be useful for those who want to migrate their torrents to Torrust. For larger datasets it would be convenient to handle errors asynchronously. In the current version the application exists immediately when something goes wrong and you have to handle the problem yourself and restart it.
+
+</Callout>
+
+You will problably need to rewrite the whole "source" part of the application to adapt it to your needs. The "destination" part should be reusable as it is.
+
+When you run the importer, the output will be something like this:
+
+<CodeBlock lang="terminal">
+
+```s
+$ cargo run
+    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
+     Running `target/debug/torrents-importer-sample`
+API login with username admin ...
+Logged as admin with account admin
+Reading file ./data/database.xml ...
+Processing channel ...
+  Title: Mandelbrot Set Collection
+  description: Torrents with Mandelbrot Set Images
+  Link: https://github.com/torrust/torrents-importer-sample
+Processing only 1 torrent ...
+Processing torrent #1 ...
+  Title: MandelBrot Set 01
+  Category: Fractal
+  Infohash: 0c90fbf036e28370c1ec773401bc7620146b1d48
+  Guid: https://raw.githubusercontent.com/torrust/torrents-importer-sample/main/tests/fixtures/torrents/mandelbrot_set_01.torrent
+  Link: https://raw.githubusercontent.com/torrust/torrents-importer-sample/main/tests/fixtures/torrents/mandelbrot_set_01.torrent
+  Description:  ...
+  Size: 17130410419
+Checking if the torrent 0c90fbf036e28370c1ec773401bc7620146b1d48 exist in the Torrust Index ...
+Downloading the torrent file from the source server ...
+Downloading torrent from https://raw.githubusercontent.com/torrust/torrents-importer-sample/main/tests/fixtures/torrents/0c90fbf036e28370c1ec773401bc7620146b1d48.torrent into ./data/torrents/0c90fbf036e28370c1ec773401bc7620146b1d48.torrent
+Torrent successfully downloaded.
+Uploading the torrent 0c90fbf036e28370c1ec773401bc7620146b1d48 to the Torrust Index ...
+response: 200
+Torrent uploaded UploadedTorrent {
+    torrent_id: 2529,
+    info_hash: "0c90fbf036e28370c1ec773401bc7620146b1d48",
+}
+Processed torrents: 1
+Uploaded torrents:  1
+```
+
+</CodeBlock>
+
+## Conclusion
+
+Being a sample project, we believe that there's always room for improvement. We invite the Torrust community to use the tool, provide feedback, and even contribute to its enhancement. Together, we can refine it and adapt it to cater to more diverse needs.
+
+We're committed to evolving and making Torrust a go-to solution for all torrent aficionados. Our new migration tool is just one step in this journey. Whether you're a casual user or an enterprise looking to migrate a large number of torrents, our tool aims to make the transition smoother for you.
+
+A big shout-out to everyone involved in this project! We encourage everyone to give it a try and share your experiences. Together, let's make the world of torrents even more connected and accessible.
+
+Happy torrenting!
+
+## Links
+
+- [The Torrust Index Backend](https://github.com/torrust/torrust-index-backend).
+- [The Torrust Torrents Importer Sample](https://github.com/torrust/torrents-importer-sample).
+
+## Acknowledgments
+
+We would like to acknowledge the team from <https://academictorrents.com/> for their great work and for making their torrents public available.
+
+If you have any questions or issues regarding this post, please [open an issue](https://github.com/torrust/torrust-website/issues/new).
+
+For any other questions or issues related to Torrust repositories, please open an issue on the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index Backend: <https://github.com/torrust/torrust-index-backend/issues>
+- Torrust Index Frontend: <https://github.com/torrust/torrust-index-frontend/issues>
+
+We very welcome any contributions to the project!
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/live-demo-beta-v3/+page.md b/src/routes/v2/(blog-article)/live-demo-beta-v3/+page.md
new file mode 100644
index 0000000..1af247f
--- /dev/null
+++ b/src/routes/v2/(blog-article)/live-demo-beta-v3/+page.md
@@ -0,0 +1,85 @@
+---
+title: Announcing the Beta v3.0.0 Live Demo
+slug: live-demo-beta-v3
+coverImage: /images/posts/rust-crab-happy.jpg
+date: 2023-12-15T12:08:04.295Z
+updated:
+excerpt: We will release a new major version v3.0.0. We want the community to test it before the final release while it's still in Beta. You can contribute to make Torrust better.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Announcement
+  - Demo
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of contents
+
+- [Hello, Torrent Enthusiasts!](#hello-torrent-enthusiasts)
+- [Experience the Beta Demo Today](#experience-the-beta-demo-today)
+- [Your Feedback Makes Us Better](#your-feedback-makes-us-better)
+- [Join the Conversation](#join-the-conversation)
+- [Important Notice: Demo Availability](#important-notice-demo-availability)
+- [A Heartfelt Thank You to Our Contributors](#a-heartfelt-thank-you-to-our-contributors)
+- [Join Us in This Exciting Journey](#join-us-in-this-exciting-journey)
+
+</PostTable>
+
+<PostBody>
+
+## **Hello, Torrent Enthusiasts!**
+
+We're thrilled to announce the beta demo of Bittorrent Torrust Index v3.0.0 is now live! This is a significant milestone for us, and we're eager to share what we've been working on with our vibrant community.
+
+<Callout type="info">
+
+Live demo: <http://index.torrust-demo.com>
+
+</Callout>
+
+## Experience the Beta Demo Today
+
+Our beta demo is your sneak peek into the future of torrent indexing. We invite you to dive in, explore its features, and experience the enhancements firsthand. Remember, this is a beta version, so you're getting an early glimpse before the final release!
+
+You can test it at: **<http://index.torrust-demo.com>**
+
+## Your Feedback Makes Us Better
+
+We believe in the power of community-driven development. That's why we're calling on you, our users, to actively participate in testing the beta.
+
+Encountered a bug? Noticed something off? We want to hear about it. Please contribute by opening issues on our GitHub repository. Your insights are invaluable in refining and perfecting the platform.
+
+## Join the Conversation
+
+Got ideas? Suggestions for improvement? Join the [discussion](https://github.com/torrust/torrust-index-gui/discussions) on our GitHub repo's discussion section. Your thoughts and proposals are a key part of our collaborative development process. Let's brainstorm together to make Torrust even better.
+
+## Important Notice: Demo Availability
+
+<Callout type="info">
+
+Please be aware that the demo is subject to downtime or resets. As a beta version, it's part of our testing process. Any data you add may be lost during these periods. We appreciate your understanding and patience as we fine-tune the platform.
+
+</Callout>
+
+## A Heartfelt Thank You to Our Contributors
+
+This release wouldn't have been possible without the dedication and hard work of our contributors. A big shout-out to everyone who has contributed their time, skills, and passion to this release. Your contributions are the backbone of this project, and we're immensely grateful for your support.
+
+## Join Us in This Exciting Journey
+
+We're just getting started, and there's much more to come. Stay tuned for more updates, and thank you for being a part of this journey. We very welcome any contributions to the projects.
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/profiling-the-torrust-bittorrent-udp-tracker/+page.md b/src/routes/v2/(blog-article)/profiling-the-torrust-bittorrent-udp-tracker/+page.md
new file mode 100644
index 0000000..80b5865
--- /dev/null
+++ b/src/routes/v2/(blog-article)/profiling-the-torrust-bittorrent-udp-tracker/+page.md
@@ -0,0 +1,339 @@
+---
+title: Profiling the Torrust BitTorrent UDP Tracker
+slug: profiling-the-torrust-bittorrent-udp-tracker
+coverImage: /images/posts/profiling-the-torrust-bittorrent-udp-tracker/profiling-the-torrust-bittorrent-udp-tracker.webp
+date: 2024-03-25T00:00:00.000Z
+updated:
+excerpt: Dive into the advanced profiling techniques driving the Torrust BitTorrent Tracker's performance. This post uncovers the tools and methods we leverage to ensure the tracker's efficiency, scalability, and our journey towards optimizing peer-to-peer file sharing.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Performance
+  - Profiling
+  - UDP Tracker
+  - Flamegraph
+  - Kcachegrind
+  - Valgrind
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Understanding The Tracker](#understanding-the-tracker)
+- [Current Challenges](#current-challenges)
+- [Internal Repository Benchmarking](#internal-repository-benchmarking)
+- [Profiling With Valgrind](#profiling-with-valgrind)
+- [Profiling With Perf](#profiling-with-perf)
+- [Conclusion](#conclusion)
+- [Acknowledgments](#acknowledgments)
+- [Links](#links)
+
+</PostTable>
+
+<PostBody>
+
+## Introduction
+
+In our quest to elevate the Torrust BitTorrent Tracker's performance, we've embraced a suite of sophisticated benchmarking and profiling tools. This article builds on our previous discussion, "[Benchmarking the Torrust BitTorrent Tracker](benchmarking-the-torrust-bittorrent-tracker)" and delves into the metrics that guide our optimization efforts. Join us as we explore the intricacies of profiling in the dynamic landscape of BitTorrent technology.
+
+In the previous article we introduced to the community the benchmarking tools we are using at the moment to know whether the Tracker performs at the same level as other applications on the market.
+
+With those benchmarking tools we ensure that the Tracker has a good performance and we don't have regressions. If you are curious about how we do benchmarking you can read the "[Benchmarking the Torrust BitTorrent Tracker](benchmarking-the-torrust-bittorrent-tracker)" article.
+
+In this article we will explain how we are collecting metrics to know which parts of the code we should improve.
+
+## Understanding The Tracker
+
+Before you continue reading this article you should know a little bit about the tracker internal structure. You can see an overview on the "[Benchmarking the Torrust BitTorrent Tracker](benchmarking-the-torrust-bittorrent-tracker)" article.
+
+<Image src="/images/posts/benchmarking-the-torrust-bittorrent-tracker/torrust-tracker-simplified-architecture.png" alt="Torrust Architecture" />
+
+## Current Challenges
+
+Balancing feature-rich functionality with performance is our central challenge. The **Torrents Repository**, a critical component, has been our focus, serving as the primary bottleneck for scaling request handling capabilities.
+
+Regardless which protocol clients use to connect to the tracker, eventually all requests reach the internal "Tracker" domain service. This tracker contains a repository with the list of all torrents. Each entry on the list contains two pieces of information:
+
+- **The statistics about that torrent**: number of seeders, leechers and peers that have completed downloading.
+- **The peer list**: a list of all the clients announcing the same torrent (swarm).
+
+<CodeBlock lang="json">
+
+```json
+{
+	"info_hash": "090c6d4fb3a03191c4ef1fda6236ef0efb2d5c10",
+	"seeders": 1,
+	"completed": 1,
+	"leechers": 0,
+	"peers": [
+		{
+			"peer_id": {
+				"id": "0x2d71423030303030303030303030303030303031",
+				"client": null
+			},
+			"peer_addr": "0.0.0.0:17548",
+			"updated": 1709916034742,
+			"updated_milliseconds_ago": 1709916034742,
+			"uploaded": 0,
+			"downloaded": 0,
+			"left": 0,
+			"event": "Completed"
+		}
+	]
+}
+```
+
+</CodeBlock>
+
+The reason why we have been focusing on that part is because we think that's the main bottleneck if we want to increase the number of requests the tracker can handle per second.
+
+The `announce` request is the most important request a tracker needs to handle. Peers get the list of other peers from the tracker by making announce requests. The purpose of that request is:
+
+- To include the peer making the request in the list of peers which are seeding or downloading the torrent.
+- Return the list of other peers so that the client can start asking for torrent pieces to the other peers.
+
+Every request is a write/read request. The system is intensive in writes. All requests eventually try to acquire a write lock to include themselves in the peer list. That's why we think that's the main bottleneck in our implementation, at the moment. For that reason we have been trying different implementations of the torrents repository:
+
+<CodeBlock lang="rust">
+
+```rust
+pub type TorrentsRwLockStd = RwLockStd<EntrySingle>;
+pub type TorrentsRwLockStdMutexStd = RwLockStd<EntryMutexStd>;
+pub type TorrentsRwLockStdMutexTokio = RwLockStd<EntryMutexTokio>;
+pub type TorrentsRwLockTokio = RwLockTokio<EntrySingle>;
+pub type TorrentsRwLockTokioMutexStd = RwLockTokio<EntryMutexStd>;
+pub type TorrentsRwLockTokioMutexTokio = RwLockTokio<EntryMutexTokio>;
+pub type TorrentsSkipMapMutexStd = CrossbeamSkipList<EntryMutexStd>; // Default
+pub type TorrentsSkipMapMutexParkingLot = CrossbeamSkipList<EntryMutexParkingLot>;
+pub type TorrentsSkipMapRwLockParkingLot = CrossbeamSkipList<EntryRwLockParkingLot>;
+pub type TorrentsDashMapMutexStd = XacrimonDashMap<EntryMutexStd>;
+```
+
+</CodeBlock>
+
+The default implementation used in production is `TorrentsSkipMapMutexStd`.
+
+<Callout type="info">
+
+**NOTICE**: All implementations are based on types that support ordering like `BTreeMap` or `SkipMap`. The reason we use those types is because the tracker API has an endpoint where you can get the ordered list of all torrents in the tracker repository.
+
+</Callout>
+
+## Internal Repository Benchmarking
+
+As we explained in a previous article ("[Benchmarking the Torrust BitTorrent Tracker](benchmarking-the-torrust-bittorrent-tracker)") you can run the benchmark for those different repository implementations with the following command:
+
+<CodeBlock lang="terminal">
+
+```terminal
+cargo bench -p torrust-tracker-torrent-repository
+```
+
+</CodeBlock>
+
+The output at the time of writing this post is similar to:
+
+<CodeBlock lang="terminal">
+
+```terminal
+     Running benches/repository_benchmark.rs (target/release/deps/repository_benchmark-a9b0013c8d09c3c3)
+add_one_torrent/RwLockStd
+                        time:   [63.057 ns 63.242 ns 63.506 ns]
+Found 12 outliers among 100 measurements (12.00%)
+  2 (2.00%) low severe
+  2 (2.00%) low mild
+  2 (2.00%) high mild
+  6 (6.00%) high severe
+add_one_torrent/RwLockStdMutexStd
+                        time:   [62.505 ns 63.077 ns 63.817 ns]
+Found 11 outliers among 100 measurements (11.00%)
+  4 (4.00%) high mild
+  7 (7.00%) high severe
+Benchmarking add_one_torrent/RwLockStdMutexTokio: Collecting 100 samples in estimated 1.0004 s (10M iterationsadd_one_torrent/RwLockStdMutexTokio
+                        time:   [98.440 ns 98.551 ns 98.660 ns]
+Found 4 outliers among 100 measurements (4.00%)
+  3 (3.00%) low mild
+  1 (1.00%) high severe
+add_one_torrent/RwLockTokio
+                        time:   [107.84 ns 108.18 ns 108.54 ns]
+Found 3 outliers among 100 measurements (3.00%)
+  2 (2.00%) low mild
+  1 (1.00%) high mild
+Benchmarking add_one_torrent/RwLockTokioMutexStd: Collecting 100 samples in estimated 1.0001 s (8.7M iterationadd_one_torrent/RwLockTokioMutexStd
+                        time:   [116.34 ns 116.48 ns 116.63 ns]
+Found 2 outliers among 100 measurements (2.00%)
+  1 (1.00%) high mild
+  1 (1.00%) high severe
+Benchmarking add_one_torrent/RwLockTokioMutexTokio: Collecting 100 samples in estimated 1.0005 s (6.9M iteratiadd_one_torrent/RwLockTokioMutexTokio
+                        time:   [143.39 ns 143.51 ns 143.63 ns]
+```
+
+</CodeBlock>
+
+## Profiling With Valgrind
+
+"Valgrind is an instrumentation framework for building dynamic analysis tools". In fact it's a suite of tools. The tool we are going to use is `callgrind` which collects data that can be later visualized with `kcachegrind`.
+
+Valgrind, coupled with Kcachegrind, offers a powerful profiling solution for in-depth analysis of BitTorrent tracker performance. By simulating cache behavior and collecting call graphs, developers gain valuable insights into code execution dynamics and potential optimizations.
+
+In order to profile the UDP tracker you need to:
+
+1. Build and run the tracker for profiling.
+2. Make requests to the tracker while it's running.
+
+Build and run the binary for profiling with:
+
+<CodeBlock lang="console">
+
+```console
+RUSTFLAGS='-g' cargo build --release --bin profiling \\
+   && export TORRUST_TRACKER_CONFIG_TOML_PATH="./share/default/config/tracker.udp.benchmarking.toml" \\
+   && valgrind \\
+     --tool=callgrind \\
+     --callgrind-out-file=callgrind.out \\
+     --collect-jumps=yes \\
+     --simulate-cache=yes \\
+     ./target/release/profiling 60
+```
+
+</CodeBlock>
+
+<Callout type="info">
+
+**NOTICE:** You should make requests to the services you want to profile. For example, using the [Aquatic UDP load test](./benchmarking-the-torrust-bittorrent-tracker).
+
+</Callout>
+
+After running the tracker with `valgrind` it generates a file called `callgrind.out`
+that you can open with `kcachegrind`.
+
+<CodeBlock lang="terminal">
+
+```terminal
+kcachegrind callgrind.out
+```
+
+</CodeBlock>
+
+<Image src="/images/posts/profiling-the-torrust-bittorrent-udp-tracker/kcachegrind-screenshot.png" alt="Visualizing profiling data with kcachegrind" />
+
+You have information like:
+
+- How many times a function is called (`Called` column).
+- The total amount of time spent running a function (`Incl.` column).
+- The total amount of time spent running a function excluding child functions (`Self` column).
+- Etcetera.
+
+But one of the most interesting things it's the interactive "Call Graph" where you can navigate through functions seeing how much time they spend.
+
+The main problem with this tool is the asynchronous code. Functions executed in tokio spawned tasks are not shown directly. Since the Torrust Tracker makes an intense use of async code that makes it harder to reach conclusions from the tool.
+
+There are alternatives that we have not tried yet:
+
+1. Use other tools like [tokio-console](https://github.com/tokio-rs/console).
+2. Insert your custom profiling functions in the code.
+3. Isolate the sync parts and profile them independently. For example, you could profile only the Torrent Repository or the Tracker domain Service.
+
+## Profiling With Perf
+
+Another alternative for profiling are flamegraphs. There is a crate called [cargo flamegraph](https://github.com/flamegraph-rs/flamegraph) that allows you to easily generate flamegraphs that you can visualize in a modern browser.
+
+Flamegraphs offer a visual representation of code execution, providing invaluable insights into performance bottlenecks within the tracker codebase. By utilizing flamegraph profiling, developers can pinpoint hotspots and inefficiencies, guiding optimization efforts for enhanced performance.
+
+After installing the `cargo flamegraph` package you can generate the flamegraph with:
+
+<CodeBlock lang="terminal">
+
+```terminal
+TORRUST_TRACKER_CONFIG_TOML_PATH="./share/default/config/tracker.udp.benchmarking.toml" cargo flamegraph --bin=profiling -- 60
+```
+
+</CodeBlock>
+
+Running the `cargo flamegraph` running the whole service produces a flamegraph like [this](/images/posts/profiling-the-torrust-bittorrent-udp-tracker/flamegraph.svg):
+
+![Visualizing profiling data with flamegraphs](/images/posts/profiling-the-torrust-bittorrent-udp-tracker/flamegraph.svg)
+
+[Click here to see the interactive flamegraph](/images/posts/profiling-the-torrust-bittorrent-udp-tracker/flamegraph.svg).
+
+As you can see, there are a lot functions for the tokio package but if you see at the top of the flame you will see the functions in the `torrust_tracker` namespace.
+
+## Conclusion
+
+Although using these tools with async code can be very challenging at least you can use them to confirm if you are making an effort on improving the performance on the right place. And you can also detect parts very slow parts.
+
+And as you can see more than 90% of the time is spent on the `Tracker::announce` method in these two functions:
+
+- `Tracker::update_torrent_with_peer_and_get_stats`.
+- `Tracker::get_torrent_peers_for_peer`.
+
+Which are the functions that need a lock to write and read in the `Torrent Repository`. Notice that it is the code we are focused on improving right now.
+
+If you see something wrong or you want to contribute by:
+
+- Adding new sections.
+- Fixing typos.
+- Making it clearer.
+- Adding links.
+- Or whatever you think that could be interesting to add,
+
+please open an [issue](https://github.com/torrust/torrust-website/issues) or a [PR](https://github.com/torrust/torrust-website/pulls).
+
+If you have any questions or issues please open an issue in the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index: <https://github.com/torrust/torrust-index/issues>
+- Torrust Website: <https://github.com/torrust/torrust-index-gui/issues>
+- Torrust Compose: <https://github.com/torrust/torrust-compose>
+- Containerizing Rust Applications Examples: <https://github.com/torrust/containerizing-rust-apps-examples>
+
+We very welcome any contributions to the projects or [this article](https://github.com/torrust/torrust-website/issues).
+
+## Acknowledgments
+
+Many thanks to [Vitaly Bragilevsky](https://github.com/bravit) and others for sharing the talks about profiling.
+
+## Links
+
+Torrust Tracker Documentation for:
+
+- [Benchmarking](https://github.com/torrust/torrust-tracker/blob/develop/docs/benchmarking.md).
+- [Profiling](https://github.com/torrust/torrust-tracker/blob/develop/docs/profiling.md).
+
+Profiling tools:
+
+- [valgrind](https://valgrind.org/).
+- [kcachegrind](https://kcachegrind.github.io/).
+- [flamegraph](https://github.com/flamegraph-rs/flamegraph).
+
+Talks about profiling:
+
+- [Profiling Rust Programs with valgrind, heaptrack, and hyperfine](https://www.youtube.com/watch?v=X6Xz4CRd6kw&t=191s).
+- [RustConf 2023 - Profiling async applications in Rust by Vitaly Bragilevsky](https://www.youtube.com/watch?v=8FAdY_0DpkM).
+- [Profiling Code in Rust - by Vitaly Bragilevsky - Rust Linz, December 2022](https://www.youtube.com/watch?v=JRMOIE_wAFk&t=8s).
+- [Xdebug 3 Profiling: 2. KCachegrind tour](https://www.youtube.com/watch?v=h-0HpCblt3A).
+
+Concurrent hash table data structures:
+
+- [DashMap](https://docs.rs/dashmap/latest/dashmap/).
+- [flurry](https://docs.rs/flurry/latest/flurry/).
+
+Tools for profiling/debugging async code:
+
+- [tokio-console](https://github.com/tokio-rs/console).
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/released-v3-0-0-alpha-12/+page.md b/src/routes/v2/(blog-article)/released-v3-0-0-alpha-12/+page.md
new file mode 100644
index 0000000..780c31c
--- /dev/null
+++ b/src/routes/v2/(blog-article)/released-v3-0-0-alpha-12/+page.md
@@ -0,0 +1,103 @@
+---
+title: Released version v3.0.0-alpha.12
+slug: released-v3-0-0-alpha-12
+coverImage: /images/posts/released-v3-0-0-alpha-12/team.png
+date: 2024-08-13T14:30:38.554Z
+updated:
+excerpt: We're excited to announce the release of v3.0.0-alpha.12, marking a significant step towards our upcoming major release, v3.0.0. This release solidifies the features and prepares us for the beta phase.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Announcement
+  - Release
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of contents
+
+- [Hello, Torrust Community!](#hello-torrust-community)
+- [What's New in v3.0.0-alpha.12](#whats-new-in-v300-alpha12)
+- [Release Schedule](#release-schedule)
+- [How to Get Involved](#how-to-get-involved)
+- [Your Feedback Makes Us Better](#your-feedback-makes-us-better)
+- [Important Notice: Demo Availability](#important-notice-demo-availability)
+- [Acknowledgments](#acknowledgments)
+
+</PostTable>
+
+<PostBody>
+
+## **Hello, Torrust Community!**
+
+We know you’ve been eagerly anticipating the next major release of Torrust, and we’re thrilled to announce that we’re one step closer. Today, we’re excited to unveil version v3.0.0-alpha.12, a milestone that locks in the features for our upcoming major release. This alpha release is a critical step in our development cycle, and your participation in testing and feedback is more important than ever.
+
+## What's New in v3.0.0-alpha.12
+
+In this release, we've focused on stabilizing the new features and refining the performance of Torrust. We’ve made several improvements under the hood that pave the way for a smoother user experience and better scalability. Here’s a quick rundown of what you can expect:
+
+- **New features:** Permanent tracker keys and allow to upload pre-generated keys. That would help users who want to migrate to the Torrust Tracker without affecting their active users.
+- **Improved configuration:** Configuration has been changed in both the Tracker and Index to make it clearer. Error messages have also been improved to help administrators to fix configuration errors.
+- **Security Updates**.
+- **UI/UX Refinements:** Minor tweaks and fixes to the user interface, enhancing usability and user experience.
+
+The live demo is always updated to the latest version. We encourage you to explore it, try out the new features, and share your thoughts.
+
+<Callout type="info">
+
+Live demo: <http://index.torrust-demo.com>
+
+</Callout>
+
+## Release Schedule
+
+The journey to our major release continues, and here’s our roadmap:
+
+| Milestone         | Target Date | Version        |
+| ----------------- | ----------- | -------------- |
+| Feature Freeze    | 15/08/2024  | 3.0.0-alpha.12 |
+| Code Freeze       | 15/08/2024  |                |
+| Beta Release      | 31/08/2024  | 3.0.0-beta     |
+| Release Candidate | 15/09/2024  | 3.0.0-rc.1     |
+| Final Release     | 30/09/2024  | 3.0.0          |
+
+## How to Get Involved
+
+Your feedback is invaluable to us. As we move towards the beta phase, we invite you to download this alpha release, test it extensively, and report any issues or suggestions you may have. Here’s how you can contribute:
+
+- Testing: Download the alpha release and run it in your environment.
+- Reporting Bugs: If you encounter any issues, please report them through our issue tracker.
+
+## Your Feedback Makes Us Better
+
+We would like the community to participate in testing this release and give us feedback.
+
+After releasing the final version 3.0.0 we want to open discussions for the roadmap. We want you to propose features to help us continue building even better tools and allow people to make use of the BitTorrent ecosystem.
+
+Got ideas? Suggestions for improvement? Join the [discussion](https://github.com/torrust/torrust-index-gui/discussions) on our GitHub repo's discussion section. Your thoughts and proposals are a key part of our collaborative development process. Let's brainstorm together to make Torrust even better.
+
+## Important Notice: Demo Availability
+
+<Callout type="info">
+
+Please be aware that the demo is subject to downtime or resets. As a beta version, it's part of our testing process. Any data you add may be lost during these periods. We appreciate your understanding and patience as we fine-tune the platform.
+
+</Callout>
+
+## Acknowledgments
+
+We want to extend our deepest thanks to all the contributors who have tirelessly tested and provided feedback on this release. Your insights have been crucial in getting us this far, and we look forward to continuing this journey together.
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/released-v3-0-0-beta/+page.md b/src/routes/v2/(blog-article)/released-v3-0-0-beta/+page.md
new file mode 100644
index 0000000..60c46ca
--- /dev/null
+++ b/src/routes/v2/(blog-article)/released-v3-0-0-beta/+page.md
@@ -0,0 +1,87 @@
+---
+title: Released version v3.0.0-beta
+slug: released-v3-0-0-beta
+coverImage: /images/posts/released-v3-0-0-beta/team.png
+date: 2024-09-03T14:30:38.554Z
+updated: 2024-09-03T14:30:38.554Z
+excerpt: We're excited to announce the release of v3.0.0-beta, marking a significant step towards our upcoming major release, v3.0.0. This release solidifies the features and prepares us for the beta phase.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Announcement
+  - Release
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of contents
+
+- [Greetings, Torrust Fans!](#greetings-torrust-fans)
+- [Release Schedule](#release-schedule)
+- [How to Participate](#how-to-participate)
+- [Your Input Helps Us Improve](#your-input-helps-us-improve)
+- [Important Notice: Demo Availability](#important-notice-demo-availability)
+- [Special Thanks](#special-thanks)
+
+</PostTable>
+
+<PostBody>
+
+## **Greetings, Torrust Fans!**
+
+As we move forward according to our release plan, we're excited to be nearing the final release of version 3.0.0.
+
+On August 13th, we made `v3.0.0-alpha.12` available, and now we're pleased to present v3.0.0-beta. This release is a critical step as we refine the software in preparation for the official launch.
+
+## Release Schedule
+
+The journey to our major release continues, and here’s our roadmap:
+
+| Milestone         | Target Date | Version        |
+| ----------------- | ----------- | -------------- |
+| Feature Freeze    | 13/08/2024  | 3.0.0-alpha.12 |
+| Code Freeze       | 13/08/2024  | 3.0.0-alpha.12 |
+| Beta Release      | 03/09/2024  | 3.0.0-beta     |
+| Release Candidate | 15/09/2024  | 3.0.0-rc.1     |
+| Final Release     | 30/09/2024  | 3.0.0          |
+
+## How to Participate
+
+Your feedback is invaluable to us. As we move towards the beta phase, we invite you to download this beta release, test it extensively, and report any issues or suggestions you may have. Here’s how you can contribute:
+
+- Testing: Download the alpha release and run it in your environment.
+- Reporting Bugs: If you encounter any issues, please report them through our issue tracker.
+
+## Your Input Helps Us Improve
+
+Your feedback is crucial in helping us refine this release. We want the community's active involvement as we move forward.
+
+After the final version 3.0.0 is released, we plan to open discussions about our future roadmap. We encourage you to propose features and improvements to help us continue building superior tools and enhance the BitTorrent ecosystem.
+
+Have ideas or suggestions? Join the [discussion](https://github.com/torrust/torrust-index-gui/discussions) on our GitHub repository. Your contributions are key to our collaborative development approach. Let’s work together to make Torrust even better!
+
+## Important Notice: Demo Availability
+
+<Callout type="warning">
+
+Please note that the [demo](https://index.torrust-demo.com/) environment may experience downtime or resets as part of our ongoing testing. As this is a beta version, data may be lost during these phases. We appreciate your patience and understanding as we fine-tune the system.
+
+</Callout>
+
+## Special Thanks
+
+We want to extend our deepest thanks to all the contributors who have tirelessly tested and provided feedback on this release. Your insights have been crucial in getting us this far, and we look forward to continuing this journey together.
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/review-and-setup-guide-for-unit3d/+page.md b/src/routes/v2/(blog-article)/review-and-setup-guide-for-unit3d/+page.md
new file mode 100644
index 0000000..52d3fa6
--- /dev/null
+++ b/src/routes/v2/(blog-article)/review-and-setup-guide-for-unit3d/+page.md
@@ -0,0 +1,385 @@
+---
+title: Review and Setup Guide for UNIT3D
+slug: review-and-setup-guide-for-unit3d
+coverImage: /images/posts/review-and-setup-guide-for-unit3d/unit3d-user-profile-screenshot.png
+date: 2024-08-16T09:36:17.990Z
+updated:
+excerpt: UNIT3D is one of the fully featured BitTorrent Indexes that promises a robust, customizable, and community-driven experience. In this first post of our review series at Torrust, we’ll dive into UNIT3D, evaluating its features, installation process, and overall usability. Whether you're an open-source advocate or a BitTorrent expert, this guide will help you understand the ins and outs of UNIT3D, including a step-by-step tutorial to set it up on a Digital Ocean droplet.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Tutorial
+  - Review
+  - Index
+  - Third-party
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+## Table of contents
+
+- [Introduction to UNIT3D](#introduction-to-unit3d)
+  - [Overview](#overview)
+  - [Key features](#key-features)
+- [UNIT3D Review](#unit3d-review)
+- [Tutorial: Setting Up UNIT3D on a Digital Ocean Droplet](#tutorial-setting-up-unit3d-on-a-digital-ocean-droplet)
+  - [Requirements](#requirements)
+  - [Step 1. Create the Droplet in Digital Ocean](#step-1-create-the-droplet-in-digital-ocean)
+  - [Step 2. Update the Server](#step-2-update-the-server)
+  - [Step 3. Run the UNIT3D Installer](#step-3-run-the-unit3d-installer)
+  - [Step 4. Login Page](#step-4-login-page)
+  - [Troubleshooting](#troubleshooting)
+- [User Interface](#user-interface)
+- [Conclusion](#conclusion)
+
+</PostTable>
+
+<PostBody>
+
+## Introduction to UNIT3D
+
+This blog post serves as an introduction to our review series at Torrust, where we'll continue to explore and evaluate other projects within the BitTorrent ecosystem.
+
+UNIT3D is a private torrent tracker software, crafted meticulously in [PHP](https://www.php.net/) using the [Laravel](https://laravel.com/) framework. Whether you're a developer looking to deploy a robust BitTorrent index or an enthusiast exploring the depths of the BitTorrent ecosystem, this guide will walk you through UNIT3D's features and provide a detailed, step-by-step setup tutorial.
+
+UNIT3D was created from scratch. The first commit was on December 2017.
+
+- **Repo:** <https://github.com/HDInnovations/UNIT3D-Community-Edition>
+- **Contributors:** [116](https://github.com/HDInnovations/UNIT3D-Community-Edition/graphs/contributors)
+- **Starts:** 1.9k.
+- **Production Stats**:
+  - Installations: 26
+  - Users: 235,041
+  - Torrents: 1,570,340
+  - Peers: 5,881,717
+- **Official Demo Site:** <https://unit3d.dev/> (currently not working).
+
+Stats from [Private-Trackers-Spreadsheet](https://hdvinnie.github.io/Private-Trackers-Spreadsheet/).
+
+<Callout type="info">
+
+To write this post we have setup a new demo site on: <https://www.unit3d-demo.com/>. Following the tutorial section you can also easily deploy your UNIT3D Index. The demo site could be shutdown at any time.
+
+</Callout>
+
+### Overview
+
+It's not our intention to list and evaluate all the features because that would be a really hard task. However we want to give you an idea about how many features this software includes:
+
+### Key features
+
+#### Torrents
+
+- Index, Search, Upload
+- Requests
+- RSS
+
+#### Community
+
+- Forums
+- Chatrooms with chatbot
+- Playlists
+- Polls
+- News
+- Bonus Points
+- User profiles
+- Achievements
+
+#### Support
+
+- Custom pages: rules, FAQ, Wikis
+- Helpdesk
+- Staff
+
+#### Platform Management
+
+- Logs
+- Access Restrictions
+  - Client Blacklist
+  - Whitelisted Image URLs
+  - Blocked IPs
+- Torrents
+  - Moderation
+  - Classification: categories, resolutions, regions, distributions
+- Peers
+- Users
+  - Search
+  - Applications, Invitations
+  - Keys: API, passkeys, RSS keys, 2FA, ...
+  - Groups (roles)
+  - Notifications (alerts)
+  - Messages
+
+#### Integrations
+
+- Torrent API: <https://github.com/HDInnovations/UNIT3D-Community-Edition/wiki/Torrent-API-(UNIT3D-v8.x.x)>
+- Other metadata API like <https://www.themoviedb.org/>
+
+## UNIT3D Review
+
+### Code Quality and Structure
+
+UNIT3D boasts a well-organized codebase, adhering to modern PHP development standards. The use of Laravel as the underlying framework ensures a modular structure, making it easier for developers to extend and customize the platform. Code readability is generally high, with well-commented sections that clarify complex logic.
+
+### Documentation and User Guides
+
+The [documentation](https://github.com/HDInnovations/UNIT3D-Community-Edition/wiki) for UNIT3D system dependencies is comprehensive, covering local development and basic server management. However, there is room for improvement in terms of end user guides, tutorials, examples, installation for production and troubleshooting guides.
+
+### Community Support and Activity
+
+UNIT3D has an active and growing community. The project's GitHub repository shows regular commits, indicating ongoing development. There are also Discord channels for sponsors where they and developers discuss issues, share tips, and contribute to the project's roadmap. You can also support UNIT3D development via <https://polar.sh/HDInnovations>.
+
+### Contribution Guidelines and License
+
+UNIT3D is licensed under the AGPL-3.0 license license. The [contribution guidelines](https://github.com/HDInnovations/UNIT3D-Community-Edition/blob/master/CONTRIBUTING.md) are well-documented, with clear instructions on how to fork the repository, submit pull requests, and report issues.
+
+### Installation Process Overview
+
+UNIT3D offers an [installer](https://github.com/HDInnovations/UNIT3D-Installer). At the time of this writing it supports:
+
+- Ubuntu 22.04 LTS (Jammy Jellyfish).
+- Ubuntu 20.04 LTS (Focal Fossa)
+
+We followed the instructions and the process was easy and fast. We will describe the process in detail in the installation tutorial. Hopefully, that will make the process even easier for other users.
+
+## Tutorial: Setting Up UNIT3D on a Digital Ocean Droplet
+
+To install the software we have followed the steps described in the official installer:
+
+<https://github.com/HDInnovations/UNIT3D-Installer>.
+
+### Requirements
+
+Although you can just execute the installer directly you will need to create some services during the installation. We would recommend to fulfill all the requirements before executing the installer, that would make the process faster and you can avoid some mistakes we made.
+
+Let's review what you will need:
+
+- Server (virtual machine)
+- External Services
+- System requirements (software installed on the server)
+
+#### Hardware Requirements (server)
+
+We opted for using a Digital Ocean droplet just because we are used to their interface and it's straightforward. Feel free to use your favorite provider.
+
+In our first attempt we used the minimum size image. However it was too small. The server had problems building the frontend and that's one of the last steps in the installation. Finally we used a VM (Digital Ocean call them droplets) with these characteristics:
+
+- Image: **Ubuntu 22.04 (LTS) x64**
+- Size: **1 vCPU; 2GB / 50GB Disk; ($12/month)**
+
+#### External Services
+
+- Domain: We registered a new one only for this purpose: <https://unit3d-demo.com/>.
+- DNS: Since We are using Digital Ocean, we only needed to assign the the Digital Ocean's name servers to the domain.
+- Email delivery service: We just picked up one from the list of supported services by UNIT3D. We selected <https://postmarkapp.com/>.
+
+How to register the domain, setup the DNS and the email service is out of the scope of this article. Anyway it depends on your providers.
+
+#### System Requirements
+
+The installer installs all the system dependencies that you need, like MySQL, Redis, etcetera. You only need a fresh Ubuntu server using one of these versions:
+
+- Ubuntu 22.04 LTS (Jammy Jellyfish).
+- Ubuntu 20.04 LTS (Focal Fossa)
+
+#### Information needed
+
+During the installation process you will need to respond to some questions. The following are the main values you will have to provide:
+
+Droplet:
+
+- Root password.
+- Hostname: `unit3d-demo`.
+
+Postmark (sign up):
+
+- Username.
+- Email.
+- Password.
+
+UNIT3D Platform Owner:
+
+- Username: We used `unit3d-owner`.
+- Email.
+- Password.
+
+MySQL:
+
+- Root password.
+- UNIT3D user: username (`unit3d`) and password.
+
+SMTP Configuration:
+
+- Driver: smtp.
+- Server: `smtp.postmarkapp.com`.
+- Port: `587`.
+- Username: A token provided by postmarkapp.
+- Password: Same as username.
+
+TMDB ([themoviedb.org](https://www.themoviedb.org/), a service to get metadata about movies):
+
+- API key.
+
+Used Versions:
+
+- OS: Ubuntu 22.04 LTS (Jammy Jellyfish)
+- PHP: 8.3.10
+- Database: 8.0.39-0ubuntu0.22.04.1
+- Laravel: 11.5.0
+- UNIT3D Community Edition: v8.1.3
+- Installation dir: `/var/www/html`
+
+Let's install the software step by step.
+
+### Step 1. Create the Droplet in Digital Ocean
+
+We decided to create a new project so we can assign resources to this project:
+
+<Image src="/images/posts/review-and-setup-guide-for-unit3d/01-new-project-in-do.png" alt="Create a new project in Digital Ocean" />
+
+And this is the droplet configuration.
+
+<Image src="/images/posts/review-and-setup-guide-for-unit3d/02-create-droplet-12-dollars.png" alt="Create a new 12-dollar droplet in Digital Ocean" />
+
+Before continuing with the tutorial make sure your root domain and `www` subdomain are pointing to the droplet's IP.
+
+<CodeBlock lang="console">
+
+```console
+ping unit3d-demo.com
+PING unit3d-demo.com (134.122.65.71) 56(84) bytes of data.
+
+ping <www.unit3d-demo.com>
+PING unit3d-demo.com (134.122.65.71) 56(84) bytes of data.
+```
+
+</CodeBlock>
+
+Also, check that you can login using SSH:
+
+<CodeBlock lang="console">
+
+```console
+ssh root@134.122.65.71
+```
+
+</CodeBlock>
+
+### Step 2. Update the Server
+
+This is only a recommendation before running the installer.
+
+<CodeBlock lang="console">
+
+```console
+sudo apt-get update
+Hit:1 http://mirrors.digitalocean.com/ubuntu jammy InRelease
+Hit:2 https://repos.insights.digitalocean.com/apt/do-agent main InRelease
+Hit:3 http://mirrors.digitalocean.com/ubuntu jammy-updates InRelease
+Hit:4 https://repos-droplet.digitalocean.com/apt/droplet-agent main InRelease
+Hit:5 http://mirrors.digitalocean.com/ubuntu jammy-backports InRelease
+Hit:6 http://security.ubuntu.com/ubuntu jammy-security InRelease
+Reading package lists... Done
+```
+
+</CodeBlock>
+
+### Step 3. Run the UNIT3D Installer
+
+<CodeBlock lang="console">
+
+```console
+sudo apt -y install git
+git clone https://github.com/HDInnovations/UNIT3D-Installer.git installer
+cd installer
+sudo ./install.sh
+```
+
+</CodeBlock>
+
+The installer has some steps:
+
+- Validate Installer Policies
+- Server Setup
+- Prerequisites
+- Database Setup
+- Php Setup (PHP & PHP-FPM Configuration)
+- Nginx Setup (Nginx Setup & Configurations)
+- Unit3d Setup (UNIT3D-Community-Edition Settings and Configuration)
+
+First, an assistant will run some checks and it will ask your preferences:
+
+<Image src="/images/posts/review-and-setup-guide-for-unit3d/03-installer.png" alt="UNIT3D Installer" />
+
+All settings are really easy, specially if you already have all the tokes and password for integrations with external services. When you finish the initial questionnaire you will reach the following confirmation point:
+
+<Image src="/images/posts/review-and-setup-guide-for-unit3d/04-last-step-installer.png" alt="UNIT3D Installer" />
+
+### Step 4. Login Page
+
+That's it. If all went fine during the installation you can load the login page:
+
+<Image src="/images/posts/review-and-setup-guide-for-unit3d/unit3d-login-page.png" alt="UNIT3D Login Page" />
+
+You can use the owner account credentials you provided during the installation.
+
+<Callout type="info">
+
+If the official demo is down you can apply for signing up in our demo on: <https://www.unit3d-demo.com/application>. You don't need to provide real data, just a valid email so we can confirm it manually. We want to highlight, however, that we may shut down this demo at any time.
+
+</Callout>
+
+### Troubleshooting
+
+During the installation we had a couple of issues.
+
+**First**, we chose to use HTTPs but the domain was not pointing the droplet's IP. The generation of the Let's Encrypt certificates with certbot failed because it was not able to reach the server to check the challenge. Once we fixed the DNS we could not continue on that point because other steps like inserting some values in the database failed. **The installation process does not allow to go back or reset to the initial state**. We needed to create a new droplet.
+
+**Second**, the initial server was too small and it stuck at building the frontend app. We got this error:
+
+<CodeBlock lang="console">
+
+```console
+[Warning] $ vite build
+error: script "build" was terminated by signal SIGKILL (Forced Quit)
+Killed
+```
+
+</CodeBlock>
+
+The problem was solved by increasing the droplet size. Anyway, It was too small to host all the services UNIT3D requires. Currently, with no users, the **CPU Usage** is at almost **30%** using a 1 vCPU; 2GB RAM instance.
+
+Finally, we also saw a warning in the Laravel logs.
+
+```text
+Base table or view not found: 1146 Table 'unit3d.torrents'
+```
+
+We opened an [issue](https://github.com/HDInnovations/UNIT3D-Community-Edition/issues/4048). However, we checked it and the table was there and the application seems to work fine.
+
+## User Interface
+
+After installing the application, we were using it for a while. We:
+
+- Uploaded a torrent.
+- Tried to send an invitation.
+
+The application has a lot of features and it can be a little bit overwhelming the first time you use it, specially if you are not used to the BitTorrent index terminology. We could not send an invitation even with the owner account because you need to give some points to the account to enable the user to send invitations. Without a basic knowledge about the common features in indexes it can be tough to understand what some features are or how to customize the index to your needs. Fortunately the maintainers offer install and tuning services.
+
+## Conclusion
+
+UNIT3D stands out as a fully-featured BitTorrent index, offering a wide array of functionalities that cater to both developers and community moderators. Its robust codebase and ease of installation are significant advantages, though newcomers may find the platform's complexity daunting. The lack of extensive documentation on best practices within the BitTorrent community is a challenge, but with support from active maintainers, users can still achieve a high level of customization and control.
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/the-enigmatic-torrent-source-field/+page.md b/src/routes/v2/(blog-article)/the-enigmatic-torrent-source-field/+page.md
new file mode 100644
index 0000000..ef2c71c
--- /dev/null
+++ b/src/routes/v2/(blog-article)/the-enigmatic-torrent-source-field/+page.md
@@ -0,0 +1,234 @@
+---
+title: The Enigmatic Torrent "Source" Field
+slug: the-enigmatic-torrent-source-field
+coverImage: /images/posts/deprecated-and-outdated-bittorrent-documentation.png
+date: 2023-08-08T13:56:28.769Z
+updated: 2023-08-08T13:56:28.769Z
+excerpt: Delving into BitTorrent’s Mysteries. What is the "source" field in the torrent info used for?
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - BitTorrent
+  - Protocol
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+The BitTorrent protocol, despite its widespread usage, has often been met with raised eyebrows by the tech community due to its sometimes vague or entirely missing documentation. Today, we'll dive into one such mystery: the "source" field located within the "info" part of torrent files.
+
+<PostContainer>
+<PostTable>
+
+## Table of contents
+
+- [Unraveling the "Source" Field](#unraveling-the-source-field)
+- ["Source" field internals](#source-field-internals)
+- [BitTorrent Documentation: Lost in the Ether?](#bittorrent-documentation-lost-in-the-ether)
+- [Cross-seeding](#cross-seeding)
+- [What are the reliable sources for BitTorrent documentation?](#what-are-the-reliable-sources-for-bittorrent-documentation)
+- [Links](#links)
+- [Acknowledgments](#acknowledgments)
+- [Conclusion](#conclusion)
+
+</PostTable>
+
+<PostBody>
+
+<Callout type="info">
+
+**Disclaimer**: The contents of this blog post, are based on research, community discussions, and available knowledge as of the date of publication. Due to the absence of official documentation for the "source" field, there might be discrepancies or potential inaccuracies in the information presented. Readers are advised to exercise caution and conduct their own research when relying on this information, especially for critical applications or decisions. If you identify any inaccuracies or have further insights, please open an issue or contact us directly so we can review and update as necessary.
+
+</Callout>
+
+## Unraveling the "Source" Field
+
+Some days ago we were testing the [Torrust Index Backend](https://github.com/torrust/torrust-index-backend). We were using different torrent files. We realized that we were calculating a wrong info-hash when the torrent contained a "source" field.
+
+You can see the details of that issue [here](https://github.com/torrust/torrust-index-backend/issues/242).
+
+For the uninitiated, the BitTorrent protocol uses `.torrent` files to contain metadata about the files we wish to share and distribute. Inside this .torrent file is an "info" dictionary that holds details about these files, such as their names, lengths, and piece hashes.
+
+You can create a torrent file in many different ways. Probably the most common way to create them is by using a BitTorrent client.
+
+For example, if you are using [qBittorrent](https://www.qbittorrent.org/), this is the torrent creation form:
+
+<Image src="/images/posts/create-a-torrent-file-with-qbittorrent-and-source-field.png" alt="Create" />
+
+As you can see there is a "source" field in the "Fields" group of inputs.
+
+As we did not know exactly the purpose of this field, our first reaction was to look for official documentation about that field in [BEPs](https://www.bittorrent.org/beps/bep_0000.html). In the context of BitTorrent, a BEP stands for "BitTorrent Enhancement Proposal." It's analogous to Python's PEP (Python Enhancement Proposal) or Bitcoin's BIP (Bitcoin Improvement Proposal).
+
+<Callout type="info">
+
+A BitTorrent Enhancement Proposal (BEP) is a design document providing information to the BitTorrent community, or describing a new feature for BitTorrent or its processes or environment. The BEP should provide a concise technical specification of the feature and a rationale for the feature. It's a mechanism by which innovations, improvements, and features are proposed, discussed, and integrated into the BitTorrent protocol and its ecosystem.
+
+</Callout>
+
+While many fields are well-documented and are integral to the functioning of the protocol, the "source" field remains a relatively understudied element. Here's what we know:
+
+**Purpose**: The "source" field isn't necessarily needed for the basic functioning of BitTorrent. It often appears to be used as a marker or tag to indicate where the torrent was created or originated. This is particularly handy for private torrent sites or groups that wish to 'mark' a torrent file to trace its distribution.
+
+**Format**: Typically, this field contains a string, which may be the name of the website or organization that created or released the torrent. Some tracker use a three-char code representing the tracker.
+
+**Implications**: While it may seem benign, the "source" field can have ramifications. Torrents marked with a particular source might be treated differently, either more trustingly or with suspicion, depending on the reputation of the source. Furthermore, for private trackers, a torrent with an unauthorized or modified "source" field might lead to banning of users, as it could indicate redistribution of exclusive content.
+
+## "Source" field internals
+
+Metainfo files (also known as .torrent files) are bencoded dictionaries. The contents of a BitTorrent file are described in the [BEP 03](https://www.bittorrent.org/beps/bep_0003.html).
+
+<Callout type="info">
+
+Bencoding (pronounced "Bee-encoding") is a data serialization method used primarily in the BitTorrent protocol. It's designed to be simple and efficient to encode and decode. Bencoded data structures include bytes (strings), integers, lists, and dictionaries.
+
+</Callout>
+
+The JSON representation of a torrent file, after decoding the bytes is something like this:
+
+<CodeBlock lang="json">
+
+```json
+{
+	"announce": "http://localhost",
+	"comment": "Comments",
+	"created by": "qBittorrent v4.4.1",
+	"creation date": 1690882922,
+	"info": {
+		"length": 172204,
+		"name": "mandelbrot_2048x2048.png",
+		"piece length": 16384,
+		"pieces": "<hex>7D 91 71 0D 9D 4D BA 88 9B 54 20 54 D5 26 72 8D 5A 86 3F E1 21 DF 77 C7 F7 BB 6C 77 96 21 66 25 38 C5 D9 CD AB 8B 08 EF 8C 24 9B B2 F5 C4 CD 2A DF 0B C0 0C F0 AD DF 72 90 E5 B6 41 4C 23 6C 47 9B 8E 9F 46 AA 0C 0D 8E D1 97 FF EE 68 8B 5F 34 A3 87 D7 71 C5 A6 F9 8E 2E A6 31 7C BD F0 F9 E2 23 F9 CC 80 AF 54 00 04 F9 85 69 1C 77 89 C1 76 4E D6 AA BF 61 A6 C2 80 99 AB B6 5F 60 2F 40 A8 25 BE 32 A3 3D 9D 07 0C 79 68 98 D4 9D 63 49 AF 20 58 66 26 6F 98 6B 6D 32 34 CD 7D 08 15 5E 1A D0 00 09 57 AB 30 3B 20 60 C1 DC 12 87 D6 F3 E7 45 4F 70 67 09 36 31 55 F2 20 F6 6C A5 15 6F 2C 89 95 69 16 53 81 7D 31 F1 B6 BD 37 42 CC 11 0B B2 FC 2B 49 A5 85 B6 FC 76 74 44 93</hex>",
+		"private": 1,
+		"source": "Source"
+	},
+	"url-list": "http://localhost/mandelbrot_2048x2048.png"
+}
+```
+
+</CodeBlock>
+
+As you can see there is one key or field called `info`. This part of the file is used to generate the info-hash, which is the torrent unique identifier.
+
+<Callout type="info">
+
+According to BEP-03, the info-hash is a 20 byte sha1 hash of the bencoded form of the info value from the metainfo file. BEP 03 does not specifically mention the `source` field. All current or future fields included in the `info` dictionary are used to calculate the info-hash.
+
+</Callout>
+
+[BEP-03](https://www.bittorrent.org/beps/bep_0003.html) does not mention the `source` and `private` fields.
+
+There are two different types of torrent files:
+
+- The single file case: where the torrent contains a single file.
+- The multi-file case: where the torrent contains a directory.
+
+Here is another example of a torrent containing multiple files:
+
+<CodeBlock lang="json">
+
+```json
+{
+	"announce": "http://localhost",
+	"comment": "Comments",
+	"created by": "qBittorrent v4.4.1",
+	"creation date": 1691069437,
+	"info": {
+		"files": [
+			{
+				"length": 37,
+				"path": ["file-425ef9ca-014d-403f-8f15-3ece9e3fad38.txt"]
+			},
+			{
+				"length": 37,
+				"path": ["file-deeafa50-2e25-4f38-bec0-92865ca6bb1d.txt"]
+			}
+		],
+		"name": "dir-839a49f0-cabc-4efb-ad5f-b6fb15f8a467",
+		"piece length": 16384,
+		"pieces": "<hex>8E 47 18 74 52 8E 68 92 DD 86 66 F0 0B DD AD B1 08 DC 69 44</hex>",
+		"private": 1
+	},
+	"url-list": "http://localhost/mandelbrot_2048x2048.png"
+}
+```
+
+</CodeBlock>
+
+<Callout type="info">
+
+The `info` dictionary can contain a key `length` or a key `files`, but not both or neither. If length is present then the download represents a single file, otherwise it represents a set of files which go in a directory structure. In the single file case, length maps to the length of the file in bytes.
+
+</Callout>
+
+## BitTorrent Documentation: Lost in the Ether?
+
+This isn’t the first time we've encountered a hazy area within BitTorrent's realm. While the protocol itself is revolutionary, providing a decentralized way to share large amounts of data efficiently, its documentation often leaves much to be desired. Here's why this is a concern:
+
+**Reduced Accessibility**: For new developers or enthusiasts looking to delve into the BitTorrent ecosystem, inadequate documentation can be a significant barrier to entry.
+
+**Inconsistent Implementations**: Vague documentation can lead to varied interpretations and consequently, inconsistent implementations across different BitTorrent clients.
+
+**Potential for Misuse**: Ambiguous or missing documentation can lead to unintended use or misuse of fields, potentially compromising the integrity of the protocol or the data being shared.
+
+## Cross-seeding
+
+It's out of the scope of this post to provide an exhaustive explanation of the cross-seeding concept. If you think it could be an interesting topic for a new blog post let us know. But the "source" field in the "info" part of the torrent files might be related to cross-seeding too.
+
+**Cross-seeding** in the BitTorrent context refers to the practice of seeding the same content (files) using two or more different torrent files, typically from different trackers. This is particularly useful when the exact same file or set of files is available on multiple trackers but might have different torrent files associated with them due to differences in metadata, source tags, or directory structures.
+
+BitTorrent clients usually do not allow you to add the same content twice, so cross-seeding is a way to get around this limitation. If you want to add a new tracker to a torrent file that you are already seeding, the client usually adds the new tracker to the tracker list in the previous torrent file. This could be a reason to ban you from some private trackers.
+
+Some private trackers change the list of trackers in the torrent files to prevent cross-seeding. They remove other trackers URLs and they also use the source file to generate a different info-hash. This is a way to force you to download the torrent file from their website and track you to know if you are seeding the torrent file from another tracker.
+
+## What are the reliable sources for BitTorrent documentation?
+
+Some of the sources we have found reliable and useful are:
+
+- <https://www.bittorrent.org/beps/bep_0000.html>: BitTorrent Enhancement Proposals (BEPs) describe proposed changes to the BitTorrent protocol, including new features and extensions to existing features.
+- <http://libtorrent.org/>: libtorrent is a feature complete C++ bittorrent library.
+- <https://wiki.theory.org/BitTorrentSpecification>: This wiki is a comprehensive reference for the BitTorrent protocol.
+
+If you think we are missing any other reliable source, please let us know by [opening an issue](https://github.com/torrust/torrust-website/issues) or opening a pull request to update this post.
+
+## Links
+
+- [The issue that originated this post](https://github.com/torrust/torrust-index-backend/issues/242).
+- [Open questions on GitHub qBittorrent project](https://github.com/qbittorrent/qBittorrent/discussions/19406).
+- [Wikipedia: Bencode](https://en.wikipedia.org/wiki/Bencode).
+- [Stackoverflow: What exactly is the info_Hash in a torrent file](https://stackoverflow.com/questions/28348678/what-exactly-is-the-info-hash-in-a-torrent-file).
+
+## Acknowledgments
+
+For this port and in other places we are using an online tool to generate JSON objects from torrent files: <https://chocobo1.github.io/bencode_online/> by [Mike Tzou](https://github.com/Chocobo1).
+
+[Kimbatt](https://github.com/Kimbatt) [helped us to find some sources of information](https://github.com/Kimbatt/torrent-creator/issues/10#issuecomment-1664344502).
+
+## Conclusion
+
+While the BitTorrent protocol remains a cornerstone of peer-to-peer data sharing, there’s a palpable need for comprehensive, clear, and easily accessible documentation. The "source" field in the "info" part of the torrent files serves as a poignant reminder of this necessity. As we continue to rely on such protocols for our digital interactions, understanding their nuances becomes not just an intellectual exercise but a practical imperative.
+
+<Callout type="info">
+
+We are looking forward to finding the first implementation and the creator of the "Source" field in the "info" part of the torrent files. If you know of any, please let us know by opening an issue.
+
+</Callout>
+
+If you have any questions or issues regarding this post, please [open an issue](https://github.com/torrust/torrust-website/issues/new).
+
+For any other questions or issues related to Torrust repositories, please open an issue on the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index Backend: <https://github.com/torrust/torrust-index-backend/issues>
+- Torrust Index Frontend: <https://github.com/torrust/torrust-index-frontend/issues>
+
+We very welcome any contributions to the project!
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/torrust-enhancing-the-bittorrent-ecosystem/+page.md b/src/routes/v2/(blog-article)/torrust-enhancing-the-bittorrent-ecosystem/+page.md
new file mode 100644
index 0000000..04753ee
--- /dev/null
+++ b/src/routes/v2/(blog-article)/torrust-enhancing-the-bittorrent-ecosystem/+page.md
@@ -0,0 +1,199 @@
+---
+title: Torrust - Enhancing the BitTorrent Ecosystem
+slug: torrust-enhancing-the-bittorrent-ecosystem
+coverImage: /images/posts/deploying-torrust-to-production/deploy-torrust-to-a-digital-ocean-droplet.png
+date: 2024-05-31T09:33:14.163Z
+updated: 2024-05-31T09:33:14.163Z
+excerpt: Torrust, an open-source organization, is making significant contributions to the BitTorrent ecosystem by developing robust tools, improving documentation, and fostering community collaboration.
+contributor: Jose Celano
+contributorSlug: jose-celano
+tags:
+  - Introduction
+  - Torrust
+hidden: false
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+<PostContainer>
+<PostTable>
+
+</PostTable>
+
+<PostBody>
+
+## Hello World! <!-- markdownlint-disable MD026 -->
+
+We haven't introduced the Torrust Organization in this blog yet, including its vision, mission, and roadmap. This should have been the first post, but after contributing to the BitTorrent ecosystem for over three years, we now have a better understanding of what the BitTorrent protocols offer and how we can enhance the ecosystem.
+
+Torrust is an Open-Source Organization. It was created by [@mickvandijke](https://github.com/mickvandijke) in 2021. Mick started by forking the UDP tracker from a [@naim94a](https://github.com/naim94a)'s' repository [https://github.com/naim94a/udpt](https://github.com/naim94a/udpt) and using some packages for the UDP tracker from [@greatest-ape](https://github.com/greatest-ape)'s [Aquatic](https://github.com/greatest-ape/aquatic) repo. [@naim94a](https://github.com/naim94a) had been working on the tracker since December 2012. In August 2022, [Nautilus Cyberneering](https://github.com/Nautilus-Cyberneering) joined the project. [@mickvandijke](https://github.com/mickvandijke) was already in contact with the Nautilus, and Nautilus decided to contribute due to the traction it was getting from the community and the alignment with their interests.
+
+We would like to thank [@naim94a](https://github.com/naim94a) and [@greatest-ape](https://github.com/greatest-ape) and all other contributors for their invaluable contributions in coding, opening issues, PRs, improving documentation, sharing ideas, etc.
+
+Over the last two years, significant efforts have been made to establish Torrust software as a leading software in the BitTorrent open-source community. We have applied the best languages, tools, and practices to bring a modern, reliable [Tracker](https://github.com/torrust/torrust-tracker) and [Index](https://github.com/torrust/torrust-index). We are close to releasing the version v3.0.0, which we consider a solid foundation for future web3 projects requiring file-sharing services.
+
+During this time, we have focused not only on building great products but also on contributing to the community in different ways like improving BitTorrent documentation, helping maintainers to maintain their Rust-based BitTorrents packages, participating in protocol discussions, and writing articles about BitTorrent.
+
+We have also prioritized onboarding contributors to the organization. We strive to provide a good experience for anyone interested in contributing, whether it's fixing a small typo, improving documentation, or submitting a large PR with a new feature. We respond quickly and make it easy to contribute, exemplified by the extensive documentation we have written.
+
+## Why is BitTorrent important?
+
+BitTorrent is a peer-to-peer (P2P) file sharing protocol, first released in 2001 by [Bram Cohen](https://github.com/bramcohen). It revolutionized file distribution across the internet by allowing efficient peer-to-peer sharing without relying on a single centralized server, making it highly resilient and scalable. BitTorrent enables each downloader to become an uploader, creating a network of file sharing that boosts download speeds and balances server loads.
+
+BitTorrent has been very often related to illegal sharing of copyrighted material, it's worth noting that BitTorrent itself is not illegal. It is a tool, and like any tool, its legality depends on how it's used. It has numerous legitimate uses such as distributing open-source software, sharing large datasets, real-time communications, and even reducing server load for large-scale events like product launches or game updates.
+
+There have been many interesting and useful projects over the years, such as:
+
+- <https://academictorrents.com/> for sharing enormous datasets, for researchers, by researchers.
+- [The Internet Archive](https://help.archive.org/help/archive-bittorrents/) is also using torrents since 2012.
+- <https://www.legittorrents.info/> was a collection of legal torrents.
+
+More recently, the [webtorrent](https://webtorrent.io/) extension has enabled BitTorrent clients to run in a browser, unlocking new capabilities like:
+
+- [PeerTube](https://peertube.cpy.re/): Prototype of a decentralized video streaming platform in the web browser.
+- [CineTimes](https://cinetimes.org/): A streaming website of public domain movies.
+- [BitChute](https://www.bitchute.com/): A decentralized video streaming social network.
+
+You can find more [here](https://webtorrent.io/faq).
+
+Despite the emergence of blockchain alternatives like [IPFS](https://ipfs.tech/) (InterPlanetary File System) or [BitTorrent File System 3.0](https://www.btfs.io/), we believe off-chain basic BitTorrent protocols without monetary incentives still fit many decentralization use cases. Many web3 applications could be based on what we already have, as shown in this [list](https://webtorrent.io/faq).
+
+## Current BitTorrent Issues
+
+After being involved in the BitTorrent ecosystem for a couple of years, we believe there is a lot of room for improvement. For example:
+
+### Documentation
+
+The source of true for BitTorrent protocols are [BEPs](https://www.bittorrent.org/beps/bep_0000.html). While it's a good starting point, the information provided is often insufficient for implementation. Important details are sometimes missing, and there are commonly applied extensions that are not documented.
+
+We aim to improve the official documentation in two stages. . First, we will write new [Torrust Enhancement Proposals](https://github.com/torrust/teps), and some of them could be converted into BEPs if they are generic enough.
+
+Not only the official protocol documentation is sometimes vague but also clients, trackers implementations, etc. We think the documentations should be:
+
+- Clear
+- Comprehensive
+- Accessible
+- Up-to-date
+- User-focused
+- Interactive and engaging
+- Easy to update and maintain
+
+And that should be for all levels, from low-level protocols to high-level end-user applications.
+
+At Torrust, we document:
+
+- Classes
+- Modules
+- Crates
+- Application (including setup, how to use, ADRs, licenses, etc)
+- Processes ((including how to contribute, how to release new version, how to make decisions, etc)
+
+### Sustainability
+
+Many projects are very old, which isn't necessarily bad because they have proven to be robust and reliable. However, onboarding new contributors is often challenging.
+
+### Scalability
+
+We haven't seen many projects ready to scale horizontally. The focus is often on optimization for a single server. For example, the Tracker uses memory to keep peer lists, making it harder to use multiple servers. While our Tracker still has this limitation, other trackers like [opentracker](https://erdgeist.org/arts/software/opentracker/) can run in a cluster.
+
+### Lack of interest
+
+Despite the advent of blockchain, it seems that average people are not concerned about the problems of centralization. Blockchain projects might still attract developers and users, but BitTorrent is often seen as "old" technology for a problem that people don't see or care about.
+
+### Missing features
+
+Several missing features make it harder to use BitTorrent in modern web3 applications:
+
+- **Versioning**: There is no official way to create versions of the same torrent. Releasing new versions requires creating a completely new torrent, which duplicates its contents.
+- **Guaranteed Seeding**: Torrents might include URLs for seeding, but hosting the content when no peer is sharing the torrent can be challenging. Blockchain-based solutions solve this problem with monetary incentives.
+- **Standards for Content Formats**: Even if you build a web3 app based on BitTorrent, interoperability is not guaranteed if content doesn't follow standards. For example, if you want to build a "hiking" app, you should specify the format of the files included in the torrents: title, description, track, images, waypoints, etc.
+
+## Vision
+
+Have you ever considered what would happen if the three big hosting providers (AWS, Azure, Google) disappeared?
+
+You would probably be affected, just like millions of others. The internet was conceived as a decentralized network (Usenet, DNS, Fidonet, etc.), but it has become increasingly centralized, raising the risk of a global collapse. Decentralized apps are more resilient, though more complex to build and less efficient.
+
+There is content that we should all care about, such as scientific papers, datasets, and user-generated data like Wikipedia.
+
+Decentralization is the only way to make data truly open and accessible for all. It also allows for interoperability and data migration, so data owners are not locked into a specific provider.
+
+Our vision is to **enable future generations to build a resilient information repositories that ensures data access for everyone**. There is a lot of valuable information locked in data centers that could be lost forever. For example, if you enjoy hiking, you might use an app to follow a track and find the starting point. This cultural heritage, created over generations, could be needed again in the future.
+
+## Mission
+
+Where does Torrust fit into this picture? We aim to improve upon this impressive technology. Torrust is dedicated to developing robust, fault-tolerant tools for the BitTorrent ecosystem, with a focus on providing good testing coverage and thorough documentation for developers and users alike.
+
+Our current portfolio includes a Tracker and an Index. The tracker, written in Rust, is a server that helps coordinate peers in the BitTorrent protocol. The Index is a website that serves as a database of torrent files, comprising a frontend web app (Index GUI) for user interaction and a backend REST API written in Rust for data and business logic (Index).
+
+We are planning to:
+
+- Provide these two components as a first step. In the medium term, we would like to extract more packages that could be used by other open-source BitTorrent projects, such as a core tracker, a tracker client library, etc.
+- Build the foundations (libraries, apps, etc.) that will enable the creation of better BitTorrent apps more efficiently in the future.
+
+## Roadmap
+
+Core:
+
+- Implement more BEPs.
+- Support for [WebTorrent](https://webtorrent.io/).
+- Extract packages that could be useful for other OS projects: tracker client, tracker checker.
+
+New features:
+
+- Permanent keys for the Tracker.
+- Peer and torrents specific statistics.
+
+Persistence:
+
+- Support other databases like PostgreSQL.
+- Migration to NoSQL?.
+
+Performance:
+
+- More optimizations for the tracker.
+
+Integrations:
+
+- Monitoring (Prometheus).
+
+Improve interoperability:
+
+- Better support for Windows.
+- Docker images for other architectures.
+
+## Why should you consider collaborating with us?
+
+Torrust is an excellent way to learn and gain practical experience with Rust and cutting-edge technologies that are quickly gaining popularity in the industry. It is also a fantastic opportunity to be part of a community that values knowledge sharing and collaboration. You can contribute to making data more open and accessible, potentially building an alternative infrastructure that can help avoid data loss or monopolization, which can be crucial for the survival of humanity.
+
+## Contributing
+
+If you see something wrong or you want to contribute to this article by:
+
+- Adding new sections.
+- Fixing typos.
+- Making it clearer.
+- Adding links.
+- Or whatever you think that could be interesting to have,
+
+please open an [issue](https://github.com/torrust/torrust-website/issues) or a [PR](https://github.com/torrust/torrust-website/pulls).
+
+If you have any questions or issues please open an issue in the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index: <https://github.com/torrust/torrust-index/issues>
+- Torrust Website: <https://github.com/torrust/torrust-index-gui/issues>
+- Torrust Compose: <https://github.com/torrust/torrust-compose>
+- Containerizing Rust Applications Examples: <https://github.com/torrust/containerizing-rust-apps-examples>
+
+We very welcome any contributions to the projects or [this article](https://github.com/torrust/torrust-website/issues).
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(blog-article)/what-is-a-bittorrent-tracker/+page.md b/src/routes/v2/(blog-article)/what-is-a-bittorrent-tracker/+page.md
new file mode 100644
index 0000000..bcd01fd
--- /dev/null
+++ b/src/routes/v2/(blog-article)/what-is-a-bittorrent-tracker/+page.md
@@ -0,0 +1,118 @@
+---
+title: What is a BitTorrent tracker and types of trackers
+slug: what-is-a-bittorrent-tracker
+coverImage: /images/posts/tracker.jpg
+date: 2023-10-05T13:42:25.671Z
+updated:
+excerpt: Basic explanation of what a BitTorrent tracker is and the two types of trackers, public and private.
+tags:
+  - Torrent
+  - Tracker
+  - BitTorrent
+hidden: false
+draft: false
+keywords:
+  - BitTorrent
+  - Tracker
+  - Torrent
+description: Basic explanation of  what a BitTorrent tracker is and the two types of trackers (public and privates).
+---
+
+<script>
+  import Callout from "$lib/components/molecules/Callout.svelte";
+  import CodeBlock from "$lib/components/molecules/CodeBlock.svelte";
+  import Image from "$lib/components/atoms/Image.svelte";
+  import PostBody from "$lib/components/molecules/PostBody.svelte";
+  import PostContainer from "$lib/components/molecules/PostContainer.svelte";
+  import PostTable from "$lib/components/molecules/PostTable.svelte";
+</script>
+
+Photo by Alex Andrews: <https://www.pexels.com/photo/shallow-focus-photography-of-black-and-silver-compasses-on-top-of-map-1203808/>.
+
+<PostContainer>
+<PostTable>
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [What is a BitTorrent Tracker](#what-is-a-bittorrent-tracker)
+- [Public trackers](#public-trackers)
+- [Private trackers](#private-trackers)
+- [BitTorrent Index vs BitTorrent Tracker](#bittorrent-index-vs-bittorrent-tracker)
+
+</PostTable>
+
+<PostBody>
+
+## Introduction
+
+Usually, when we think about Torrents, we think about a program used to download files from a group of people through the internet. But some of those users don’t know what a tracker is.
+
+In this article, I will explain a BitTorrent tracker and the two types of trackers (public and private).
+
+## What is a BitTorrent Tracker
+
+A BitTorrent tracker is a server (actually an app running on a server) that helps peers who use the BitTorrent protocol share their files.
+
+It is responsible for keeping track of what peer machines (BitTorrent clients and their IPs) have what files and whether they are available or not, so when you add a .torrent file to your torrent client, the tracker lets you know where to start getting parts of that file.
+
+It also helps with the communication between peers and data transmission, making the entire process more efficient.
+
+When downloading files, the client will go back to the tracker every once in a while to send statistics and improve the download speed, as it gets newly updated info about other peers sharing the files.
+
+## Public trackers
+
+Public trackers are open to everybody. They don’t require registration, even though some will allow it and provide benefits to those users. They usually contain torrent files about different themes (music, films, games, etc.).
+
+They are the most straightforward way to get torrents, which may be a good starting point for beginners.
+
+There are also some cons when using public trackers.
+
+Malware can be found in torrent files and websites, which many people use. It is the perfect target for people with malicious intentions. You should always check for .exe, .bat or other executable files, and remember to read the comments of the torrent file you want to download.
+
+You can also wait a few days if the torrent is new and let other people test the file and see if they comment about the torrent containing any malware.
+
+Another downside regarding security is that if you don’t use methods to avoid tracking, like a VPN, anyone can get access to your IP.
+
+Also, public trackers may attract more attention from authorities. Hence, using public trackers to download illegal stuff has a greater chance of getting you into trouble.
+
+## Private trackers
+
+Private trackers require registration. Some of them are also hidden, and their access depends on private invitations or a process defined by the tracker. It may include an interview or other means.
+
+Private trackers usually contain better-quality torrents and hard-to-find ones.
+
+They might ask you to have a good ratio, so when using them, you need to make sure you share files and download them, which can be cumbersome at times.
+
+It is still recommended that you use a VPN to increase privacy and security; people can still access your IP if not hidden, and authorities can still lurk around private torrents.
+
+Also, always be aware of malware on private trackers.
+
+I also recommend using common sense regarding sharing private information in the interview process, which some private trackers require.
+
+## BitTorrent Index vs BitTorrent Tracker
+
+It is essential to differentiate between a BitTorrent tracker and an index, as some people use the terms index and tracker indistinctively when, actually, there are two different things.
+
+A BitTorrent index is a website that serves as a directory of classified torrent files where users can search for and download them.
+
+When you download a torrent file from a BitTorrent index site, it usually contains a list of URLs for trackers where your client can request torrent pieces.
+
+Often, the index site has an associated tracker that is included in the list of tracker URLs in the torrent file.
+
+A tracker, as previously described above, takes care of efficient data transmission between the peers in the swarm when sharing files using the BitTorrent protocol.
+
+**I hope you have found this article useful!**
+
+If you have any questions or issues regarding this post, please [open an issue](https://github.com/torrust/torrust-website/issues/new).
+
+For any other questions or issues related to Torrust repositories, please open an issue on the corresponding repository:
+
+- Torrust Tracker: <https://github.com/torrust/torrust-tracker/issues>
+- Torrust Index Backend: <https://github.com/torrust/torrust-index-backend/issues>
+- Torrust Index Frontend: <https://github.com/torrust/torrust-index-frontend/issues>
+
+We very welcome any contributions to the project!
+
+</PostBody>
+</PostContainer>
diff --git a/src/routes/v2/(waves)/+page.svelte b/src/routes/v2/(waves)/+page.svelte
index 4a5e18c..09e0654 100644
--- a/src/routes/v2/(waves)/+page.svelte
+++ b/src/routes/v2/(waves)/+page.svelte
@@ -18,5 +18,15 @@
 <WhyContribute />
 {#if posts && posts.length}
 	<RecentPosts {posts} />
+	<div class="link-container">
+		<a href="/v2/blog">All articles</a>
+	</div>
 {/if}
 <Footer />
+
+<style lang="scss">
+	.link-container {
+		text-align: center;
+		padding-top: 3rem;
+	}
+</style>