Before diving into creating ICP Canisters with Rust, let's set up your Rust development environment to ensure a smooth workflow. Rust offers a powerful toolset for system-level programming and web development alike. We'll install Rust and configure it for the project.

Rust comes with a dedicated package manager called "Cargo" that makes managing dependencies and building projects a breeze. If you already have Rust set up, you can skip this step.

To install Rust, we'll use rustup, the official Rust toolchain installer. Run the following command in your terminal to install Rust:

curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

After running the command, you should see a welcome message, that will ask you how to proceed with the installation:

1...
2
3Current installation options:
4
5   default host triple: x86_64-unknown-linux-gnu
6     default toolchain: stable (default)
7               profile: default
8  modify PATH variable: yes
9
101) Proceed with installation (default)
112) Customize installation
123) Cancel installation
13>

Press 1 and hit enter or just directly press enter to proceed with the installation since 1 is selected as default.

After the installation is complete, you should see a similar output in your terminal:

1
2Rust is installed now. Great!
3
4To get started you may need to restart your current shell.
5This would reload your PATH environment variable to include
6Cargo's bin directory ($HOME/.cargo/bin).
7
8To configure your current shell, run:
9source "$HOME/.cargo/env"

Next run the source command to ensure that the necessary environment variables are loaded:

source "$HOME/.cargo/env"

This completes the installation of Rust. In the next section, we'll install the necessary dependencies for our project.

1.2.2 Installing wasm32-unknown-unknown target

Next, we need to install the wasm32-unknown-unknown target, which is a WebAssembly target for the Rust programming language. So that we can compile Rust code to WebAssembly and run it on the Internet Computer.

Run the following command to install the wasm32-unknown-unknown target:

rustup target add wasm32-unknown-unknown

1.2.3 Installing Candid Extractor

Next, we need to install Candid Extractor, a tool which allows you to extract Candid interface definitions from WebAssembly modules. This enables us to generate Candid interface definitions for our canister to interact with it.

Run the following command to install Candid Extractor:

cargo install candid-extractor

1.2.4 Installing DFX

We'll also need DFX, a command-line interface for the Internet Computer. DFX allows you to create, build, deploy, and manage canisters on the platform. It also offers a local development environment for testing.

Install DFX by running:

DFX_VERSION=0.15.0 sh -ci "$(curl -fsSL https://sdk.dfinity.org/install.sh)"

Now that we have DFX installed, you need to add it to your path. Run the following command:

echo 'export PATH="$PATH:$HOME/bin"' >> "$HOME/.bashrc"

1.2.6 Ensuring Everything is Installed Correctly

1. Close and Reopen Your Terminal: Close and reopen your terminal to ensure the new environment variables are loaded.

2. Check the Installed Rust Version: Run the following command to check the installed Rust version:

    cargo --version
   

   You should see something like this:

    cargo 1.72.0 (103a7ff2e 2023-08-15)
   

3. Check the Installed DFX Version: Run the following command to check the installed DFX version:

    dfx --version
   

   You should see something like this:

    dfx 0.15.0
   

With all the dependencies installed, we're ready to start building our canister.

Apache is available within Ubuntu’s default software repositories, making it possible to install it using conventional package management tools.

Begin by updating the local package index to reflect the latest upstream changes:

sudo apt update

Then, install the apache2 package:

sudo apt install apache2

After confirming the installation, apt will install Apache and all required dependencies.

Step 2 — Adjusting the Firewall

Before testing Apache, it’s necessary to modify the firewall settings to allow outside access to the default web ports. If you followed the instructions in the prerequisites, you should have a UFW firewall configured to restrict access to your server.

During installation, Apache registers itself with UFW to provide a few application profiles that can be used to enable or disable access to Apache through the firewall.

List the ufw application profiles by running the following:

sudo ufw app list

Your output will be a list of the application profiles:

OutputAvailable applications:
  Apache
  Apache Full
  Apache Secure
  OpenSSH

As indicated by the output, there are three profiles available for Apache:

• Apache: This profile opens only port 80 (normal, unencrypted web traffic)

• Apache Full: This profile opens both port 80 (normal, unencrypted web traffic) and port 443 (TLS/SSL encrypted traffic)

• Apache Secure: This profile opens only port 443 (TLS/SSL encrypted traffic)

It is recommended that you enable the most restrictive profile that will still allow the traffic you’ve configured. Since you haven’t configured SSL for your server yet in this guide, you’ll only need to allow traffic on port 80:

sudo ufw allow 'Apache'

You can verify the change by checking the status:

sudo ufw status

The output will provide a list of allowed HTTP traffic:

OutputStatus: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
Apache                     ALLOW       Anywhere                
OpenSSH (v6)               ALLOW       Anywhere (v6)             
Apache (v6)                ALLOW       Anywhere (v6)

As indicated by the output, the profile has been activated to allow access to the Apache web server.

Step 3 — Checking your Web Server

At the end of the installation process, Ubuntu 22.04 starts Apache. The web server will already be up and running.

Make sure the service is active by running the command for the systemd init system:

sudo systemctl status apache2

Output● apache2.service - The Apache HTTP Server
     Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor prese>
     Active: active (running) since Tue 2022-04-26 15:33:21 UTC; 43s ago
       Docs: https://httpd.apache.org/docs/2.4/
   Main PID: 5089 (apache2)
      Tasks: 55 (limit: 1119)
     Memory: 4.8M
        CPU: 33ms
     CGroup: /system.slice/apache2.service
             ├─5089 /usr/sbin/apache2 -k start
             ├─5091 /usr/sbin/apache2 -k start
             └─5092 /usr/sbin/apache2 -k start

As confirmed by this output, the service has started successfully. However, the best way to test this is to request a page from Apache.

You can access the default Apache landing page to confirm that the software is running properly through your IP address. If you do not know your server’s IP address, you can get it a few different ways from the command line.

Try writing the following at your server’s command prompt:

hostname -I

You will receive a few addresses separated by spaces. You can try each in your web browser to determine if they work.

Another option is to use the free icanhazip.com tool. This is a website that, when accessed, returns your machine’s public IP address as read from another location on the internet:

curl -4 icanhazip.com

When you have your server’s IP address, enter it into your browser’s address bar:

http://your_server_ip

You will see the default Ubuntu 22.04 Apache web page as in the following:

This page indicates that Apache is working correctly. It also includes some basic information about important Apache files and directory locations.

Step 4 — Managing the Apache Process

Now that you have your web server up and running, let’s review some basic management commands using systemctl.

To stop your web server, run:

sudo systemctl stop apache2

Copy

To start the web server when it is stopped, run:

sudo systemctl start apache2

To stop and then start the service again, run:

sudo systemctl restart apache2

If you are simply making configuration changes, Apache can often reload without dropping connections. To do this, use the following command:

sudo systemctl reload apache2

By default, Apache is configured to start automatically when the server boots. If this is not what you want, disable this behavior by running:

sudo systemctl disable apache2

To re-enable the service to start up at boot, run:

sudo systemctl enable apache2

Apache will now start automatically when the server boots again.

In the ever-evolving landscape of frontend development, the need for speed and efficiency is paramount. With Vite, the lightning-fast frontend build tool, and the seamless integration between GitHub and Vercel, deploying React applications has never been more straightforward. In this guide, we will explore how to create a React app using the latest version of Vite and deploy it on GitHub with Vercel, ensuring a smooth and efficient development process.

Prerequisites

Before we dive in, make sure you have the following prerequisites installed and set up:

1. Node.js: Ensure you have Node.js installed on your system. You can download and install it from nodejs.org.

2. Git: Install Git from git-scm.com.

3. GitHub Account: If you don’t have a GitHub account, you can sign up for free at github.com.

4. Vercel Account: Create a Vercel account at vercel.com.

Step 1: Installing Vite

First, let’s install the latest version of Vite globally on your system using npm. Open your terminal or command prompt and run the following command:

npm install -g create-vite@latest

Step 2: Creating a New Vite Project

Create a new React project using Vite by running the following command in your terminal:

create-vite my-react-app --template react

This command sets up a new React project in a folder named my-react-app.

Step 3: Navigating to Your Project Directory

Move into your project directory using the cd command:

cd my-react-app

Step 4: Developing Your React App

Start your development server by running:

npm run dev

This command launches a development server, allowing you to preview your React app locally.

Step 5: Setting Up GitHub Repository

Initialize a new Git repository in your project folder:

git init

Create a new repository on GitHub. Follow the instructions provided on GitHub to add your existing repository to your project folder.

Step 6: Deploying on Vercel

1. Install the Vercel CLI globally if you haven’t already:

npm install -g vercel

1. Deploy your React app on Vercel by running the following command:

vercel

Follow the prompts, and Vercel will guide you through the deployment process. Once deployed, Vercel will provide you with a unique URL for your React app.

URL for my React App

https://vite-project-psi-seven.vercel.app/

Conclusion

In this guide, we explored the process of creating a lightning-fast React app using the latest version of Vite and seamlessly deploying it on GitHub with Vercel. The combination of Vite’s speed and GitHub + Vercel integration provides developers with an efficient workflow, allowing them to focus on building exceptional user experiences.