Compare revisions

# This file is a template, and might need editing before it works on your project.

# Full project: https://gitlab.com/pages/plain-html

pages:

  stage: deploy

  image: carinerey/r_for_beginners

  image: ghcr.io/quarto-dev/quarto

  script:

    - mkdir -p public/

    - cp -R img public/

    - make

    - quarto -v

    - |

      quarto render

      mkdir public

      cp -r _book/* public/

  interruptible: true

  artifacts:

    paths:

      - public

  rules:

  rules:

    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

    - if: $CI_PIPELINE_SOURCE == 'merge_request_event'

---

title: Install system programs

author: "Laurent Modolo"

output:

  rmdformats::downcute:

    self_contain: true

    use_bookdown: true

    default_style: "light"

    lightbox: true

    css: "./www/style_Rmd.css"

---

```{r include = FALSE}

if (!require("fontawesome")) {

  install.packages("fontawesome")

}

if (!require("klippy")) {

  install.packages("remotes")

  remotes::install_github("rlesur/klippy")

}

library(fontawesome)

knitr::opts_chunk$set(echo = TRUE)

knitr::opts_chunk$set(comment = NA)

klippy::klippy(

  position = c('top', 'right'),

  color = "white",

  tooltip_message = 'Click to copy',

  tooltip_success = 'Copied !')

```

[![cc_by_sa](./img/cc_by_sa.png)](http://creativecommons.org/licenses/by-sa/4.0/)

<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">

<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" />

</a>

Objective: Learn how to install programs in GNU/Linux

As we have seen in the [4 Unix file system](http://perso.ens-lyon.fr/laurent.modolo/unix/4_unix_file_system.html#lib-and-usrlib) session, programs are files that contain instruction for the computer to do things. Those files can be in binary or text format (with a [shebang](http://perso.ens-lyon.fr/laurent.modolo/unix/9_batch_processing.html#shebang)). Any of those files, present in a folder of the [**PATH**](http://perso.ens-lyon.fr/laurent.modolo/unix/9_batch_processing.html#path) variable are executable anywhere by the user. For system wide installation, the program files are copied within shared folder path containained in the [**PATH**](http://perso.ens-lyon.fr/laurent.modolo/unix/9_batch_processing.html#path) variable.

As we have seen in the [4 Unix file system](http://perso.ens-lyon.fr/laurent.modolo/unix/4_unix_file_system.html#lib-and-usrlib) session, programs are files that contain instruction for the computer to do things. Those files can be in binary or text format (with a [shebang](http://perso.ens-lyon.fr/laurent.modolo/unix/9_batch_processing.html#shebang)). Any of those files, present in a folder of the [**PATH**](http://perso.ens-lyon.fr/laurent.modolo/unix/9_batch_processing.html#path) variable are executable anywhere by the user. For system-wide installation, the program files are copied within shared folder path contained in the [**PATH**](http://perso.ens-lyon.fr/laurent.modolo/unix/9_batch_processing.html#path) variable.

Developers don’t want to reinvent the wheel each time they want to write complex instruction in their programs, this is why they use shared library of pre-written complex instruction. This allows for quicker development, fewer bugs (we only have to debug the library once and use it many times), and also [better memory management](http://perso.ens-lyon.fr/laurent.modolo/unix/6_unix_processes.html#processes-tree) (we only load the library once and it can be used by different programs).

Developers don't want to reinvent the wheel each time they want to write complex instruction in their programs, this is why they use a shared library of pre-written complex instruction. This allows for quicker development, fewer bugs (we only have to debug the library once and use it many times), and also [better memory management](http://perso.ens-lyon.fr/laurent.modolo/unix/6_unix_processes.html#processes-tree) (we only load the library once and it can be used by different programs).

# Package Manager

## Package Manager

However, interdependencies between programs and libraries can be a nightmare to handle manually this is why most of the time when you install a program you will use a [package manager](https://en.wikipedia.org/wiki/Package_manager). [Package managers](https://en.wikipedia.org/wiki/Package_manager) are system tools that will handle automatically all the dependencies of a program. They rely on **repositories** of programs and library which contains all the information about the trees of dependence and the corresponding files (**packages**).

However, interdependencies between programs and libraries can be a nightmare to handle manually this is why most of the time when you install a program you will use a [package manager](https://en.wikipedia.org/wiki/Package_manager). [Package managers](https://en.wikipedia.org/wiki/Package_manager) are system tools that will handle automatically all the dependencies of a program. They rely on **repositories** of programs and library which contain all the information about the trees of dependence and the corresponding files (**packages**).

Systemwide installation steps:

System-wide installation steps:

- The user asks the package manager to install a program

- The **package manager** queries its repository lists to search for the most recent **package** version of the program (or a specific version)

- The **package manager** construct the dependency tree of the program

- The **package manager** check that the new dependency tree is compatible with every other installed program

- The **package manager** install the program **package** and all its dependencies **packages** in their correct version

- The **package manager** constructs the dependency tree of the program

- The **package manager** checks that the new dependency tree is compatible with every other installed program

- The **package manager** installs the program **package** and all its dependencies **packages** in their correct version

The main difference between GNU/Linux distribution is the package manager they use

- Gentoo: [portage](https://en.wikipedia.org/wiki/Portage_(software))

- Alpine: [apk](https://wiki.alpinelinux.org/wiki/Alpine_newbie_apk_packages)

Packages manager install the packages in **root** owned folders, you need **root** access to be able to use them.

Packages manager install the packages in **root** owned folders, you need **root** access to use them.

<details><summary>Solution</summary>

<p>

</p>

</details>

## Installing R

### Installing R

**R** is a complex program that relies on loots of dependencies. Your current VM run on Ubuntu, so we are going to use the `apt` tool (`apt-get` is the older version of the `apt` command, `synaptic` is a graphical interface for `apt-get`).

What is the **R** version that you installed? Is there a newer version of **R**?

## Adding a new repository

### Adding a new repository

You can check the list of repositories that `apt` checks in the file `/etc/apt/sources.list`.

You can add the official cran repository to your repositories list:

```sh

sudo add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu <release_name>-cran40/'

sudo add-apt-repository "deb https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran40/"

```

You can use the command `lsb_release -sc` to get your **release name**.

The command `lsb_release -sc` automatically fetches your distribution **release name**.

Then you must add the public key of this repository:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9

```

## Updating the repository list

### Updating the repository list

You can now use `apt` to update your repository list dans try to reinstall  **r-base-core**

You can now use `apt` to update your repository list and try to reinstall  **r-base-core**

<details><summary>Solution</summary>

<p>

</p>

</details>

With the combination of `update` and `upgrade` you can keep your whole system up to date the even the kernel files is just another package. You can use `apt` to search for the various versions of the `linux-image`.

With the combination of `update` and `upgrade`, you can keep your whole system up to date the even the kernel files are just another package. You can use `apt` to search for the various versions of the `linux-image`.

<details><summary>Solution</summary>

<p>

</details>

### Language specific package manager

## Language specific package manager

If it’s not a good idea to have different **package manager** on the same system (they don’t know how the dependencies are handled by the other’s manager). You will also encounter language specific package manager:

If it's not a good idea to have different **package manager** on the same system (they don't know how the dependencies are handled by the other managers). You will also encounter language specific package manager:

- `ppm` for Perl

- `pip` for Python

These **package managers** allow you to make installation local to the user, which is advisable to avoid any conflict with the **packages manager** of the system.

For example, you can use the following command to install `glances` system wide with `pip`

For example, you can use the following command to install `glances` system-wide with `pip`

```sh

sudo pip3 install glances

You can now try to install `glances` with `apt`

What is the `glances` version installed with `apt`, what is the one installed with `pip` ? What is the version of the `glances` of your **PATH** ?

What is the `glances` version installed with `apt`, what is the one installed with `pip`? What is the version of the `glances` in your **PATH**?

Next-time use `pip` with the `--user` switch.

## Manual installation

# Manual installation

Sometimes, a specific tool that you want to use will not be available through a **package manager**. If you are lucky, you will find a **package** for your distribution. For `apt` the **package** are `.deb` files.

Sometimes, a specific tool that you want to use will not be available through a **package manager**. If you are lucky, you will find a **package** for your distribution. For `apt`, the **package** are `.deb` files.

For example, you can download `simplenote` version 2.7.0 for your architecture [here](https://github.com/Automattic/simplenote-electron/releases/tag/v2.7.0).

You can then use `apt` to install this file.

# From sources

## From sources

If the program is open source, you can also [download the sources](https://github.com/Automattic/simplenote-electron/archive/v2.7.0.tar.gz) and build them.

You can use the command `tar -xvf` to extract this archive

When you go into the `simplenote-electron-2.7.0` folder, you can see a `Makefile` this means that you can use the `make` command to build Simplenote from those files. `make` is a tool that read recipes (`Makefiles`) to build programs.

When you go into the `simplenote-electron-2.7.0` folder, you can see a `Makefile`. This means that you can use the `make` command to build Simplenote from those files. `make` is a tool that read recipes (`Makefiles`) to build programs.

You can try to install `node` and `npx` with `apt`. What happened?

</p>

</details>

And now you understand why program packaging takes time in a project, and why it’s important !

And now you understand why program packaging takes time in a project, and why it's important!

You can finalize the installation with the command `make install`. Usually the command to build a tool is available in the `README.md` file of the project.

You can finalize the installation with the command `make install`. Usually, the command to build a tool is available in the `README.md` file of the project.

Read the `README` file of the [fastp](https://github.com/OpenGene/fastp) program to see which methods of installation are available.

---

title: Virtualization

author: "Laurent Modolo"

output:

  rmdformats::downcute:

    self_contain: true

    use_bookdown: true

    default_style: "light"

    lightbox: true

    css: "./www/style_Rmd.css"

---

```{r include = FALSE}

if (!require("fontawesome")) {

  install.packages("fontawesome")

}

if (!require("klippy")) {

  install.packages("remotes")

  remotes::install_github("rlesur/klippy")

}

library(fontawesome)

knitr::opts_chunk$set(echo = TRUE)

knitr::opts_chunk$set(comment = NA)

klippy::klippy(

  position = c('top', 'right'),

  color = "white",

  tooltip_message = 'Click to copy',

  tooltip_success = 'Copied !')

```

[![cc_by_sa](./img/cc_by_sa.png)](http://creativecommons.org/licenses/by-sa/4.0/)

<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">

<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" />

</a>

Objective: Learn how to build virtual images or container of a system

You can save the state of the whole **guest** system using a **snapshot**. The **snapshots** can then be executed on any other **hypervisor**. This as several benefits:

- If the **host** has a hardware failure, the **snapshots** can be executed on another **host** to avoid service interruption

- For scalable system, as many **guest** systems as necessary can be launched adaptively on many **host** systems to handle peak consumption. When the peak is over, we can easily stop the additional **guest** systems.

- For computing science a **snapshot** of a suite of tools allows to you run the same computation as it also captures all the software (and simulated) hardware environment.

- For scalable systems, as many **guest** systems as necessary can be launched adaptively on many **host** systems to handle peak consumption. When the peak is over, we can easily stop the additional **guest** systems.

- For computing sciences, a **snapshot** of a suite of tools allows to you run the same computation as it also captures all the software (and simulated) hardware environment.

To avoid the overhead of simulating every component of the **guest** system, which means that the **hypervisor** programs must run code that simulates a given hardware and code that simulate the **guest** programs running on this hardware, some part of the **host** system can be shared (with control) with the **guest** system.

There are different levels of virtualisation which correspond to different levels of isolation between the virtual machine (**guest**) and the real computer (**host**). 

# Full virtualization

## Full virtualization

A key challenge for full virtualization is the interception and  simulation of privileged operations, such as I/O instructions. The  effects of every operation performed within a given virtual machine must be kept within that virtual machine – virtual operation cannot be  allowed to alter the state of any other virtual machine, the control  program, or the hardware. Some machine instructions can be executed  directly by the hardware, since their effects are entirely contained  within the elements managed by the control program, such as memory  locations and arithmetic registers. But other instructions that would  "pierce the virtual machine" cannot be allowed to execute directly; they must instead be trapped and simulated. Such instructions either access  or affect state information that is outside the virtual machine.

A key challenge for full virtualization is the interception and simulation of privileged operations, such as I/O instructions. The effects of every operation performed within a given virtual machine must be kept within that virtual machine; virtual operations cannot be allowed to alter the state of any other virtual machine, the control program, or the hardware. Some machine instructions can be executed  directly by the hardware, since their effects are entirely contained  within the elements managed by the control program, such as memory locations and arithmetic registers. But other instructions that would "pierce the virtual machine" cannot be allowed to execute directly; they must instead be trapped and simulated. Such instructions either access or affect state  information that is outside the virtual machine.

# Paravirtualization

## Paravirtualization

In paravitualization, the virtual hardware of the **guest** system is similar to the hardware of the **host**. The goal is to reduce the portion of the **guest** execution time spent to simulate hardware which is the same as the **host** hardware. The paravirtualization provides specially defined **hooks** to allow the  **guest** and **host** to request and acknowledge these tasks, which would  otherwise be executed in the virtual domain (where execution performance is worse).

A hypervisor provides the virtualization of the underlying computer system. In [full virtualization](https://en.wikipedia.org/wiki/Full_virtualization), a guest operating system runs unmodified on a hypervisor. However, improved performance and efficiency is achieved by having the guest operating system communicate with the hypervisor. By allowing the guest operating system to indicate its intent to the hypervisor, each can cooperate to obtain better performance when running in a virtual  machine. This type of communication is referred to as paravirtualization.

# OS-level virtualization

## OS-level virtualization

**OS-level virtualization** is an [operating system](https://en.wikipedia.org/wiki/Operating_system) paradigm in which the [kernel](https://en.wikipedia.org/wiki/Kernel_(computer_science)) allows the existence of multiple isolated [user space](https://en.wikipedia.org/wiki/User_space) instances. Such instances, called **containers** may look like real computers from the point of view of programs running in them. Programs running inside a container can only see the container's contents and devices assigned to the container.

# VirtualBox

## VirtualBox

VirtualBox is own by oracle, you can add the following repository to get the last version:

sudo usermod -G vboxusers -a $USER

```

The first thing that we need to do with virtual box is to create a new virtual machine. We want to install Ubuntu 20.04 on it.

The first thing that we need to do with a virtual box is to create a new virtual machine. We want to install Ubuntu 20.04 on it.

```sh

VBoxManage createvm --name Ubuntu20.04 --register

VBoxManage modifyvm Ubuntu20.04 --memory 1024

```

We add a virtual IDE peripheric storage on which we can boot on.

We add a virtual IDE storage device on which we can boot on.

```sh

VBoxManage storagectl Ubuntu20.04 --name IDE --add ide --controller PIIX4 --bootable on

```

And add an ubuntu image to this IDE device

And add an Ubuntu image to this IDE device

```sh

wget https://releases.ubuntu.com/20.10/ubuntu-20.10-live-server-amd64.iso

VBoxManage storageattach Ubuntu20.04 --storagectl IDE --port 0 --device 0 --type dvddrive --medium "/home/etudiant/ubuntu-20.10-live-server-amd64.iso"

```

Add a network interface

Then, add a network interface

```sh

VBoxManage modifyvm Ubuntu20.04 --nic1 nat --nictype1 82540EM --cableconnected1 on

Why did this last command fail? Which kind of virtualisation VirtualBox is using?

# Docker

## Docker

Docker is an **OS-level virtualization** system where the virtualization is managed by the `docker` daemon.

docker rmi rocker/rstudio:3.2.0

```

Try to run the `mcr.microsoft.com/windows/servercore:ltsc2019` container, what is happening ?

Try to run the `mcr.microsoft.com/windows/servercore:ltsc2019` container. What is happening?

## Building your own container

### Building your own container

You can also create your own container by writing a container recipe. For Docker this file is named `Dockerfile`

You can also create your own container by writing a container recipe. For Docker this file is named `Dockerfile`.

The first line of such recipe is a `FROM` statement. You don't start from scratch like in VirtualBox, but from a bare distribution:

The first line of a `Dockerfile` contains a `FROM` statement. You don't start from scratch like in VirtualBox, but from a bare distribution:

```dockerfile

FROM ubuntu:20.04

```

From this point you can add instructions

From this point, you can add instructions

`COPY` will copy files from the `Dockerfile` directory to a path inside the container

COPY .bashrc /

```

`RUN`will execute command inside the container

`RUN`will execute commands inside the container

```dockerfile

RUN apt updatge && apt install -y htop

# Singularity

## Singularity

Like Docker, Singularity is an **OS-level virtualization**. This main difference with docker is that the user is the same within and outside a container. Singularity is available on the [neuro.debian.net](http://neuro.debian.net/install_pkg.html?p=singularity-container) repository, you can add this source with the following commands:

```sh

singularity exec docker://alpine:latest apk

```

---

title: Understanding a computer

author: "Laurent Modolo"

output:

  rmdformats::downcute:

    self_contain: true

    use_bookdown: true

    default_style: "light"

    lightbox: true

    css: "./www/style_Rmd.css"

---

```{r include = FALSE}

if (!require("fontawesome")) {

  install.packages("fontawesome")

}

if (!require("klippy")) {

  install.packages("remotes")

  remotes::install_github("rlesur/klippy")

}

library(fontawesome)

knitr::opts_chunk$set(echo = TRUE)

knitr::opts_chunk$set(comment = NA)

klippy::klippy(

  position = c('top', 'right'),

  color = "white",

  tooltip_message = 'Click to copy',

  tooltip_success = 'Copied !')

```

<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">

<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" />

</a>

Objective: understand the relations between the different components of a computer

# Which parts are necessary to define a computer ?

## Which parts are necessary to define a computer?

# Computer components

## Computer components

## CPU (Central Processing Unit)

### CPU (Central Processing Unit)

![CPU](./img/amd-ryzen-7-1700-cpu-inhand1-2-1500x1000.jpg){width=100%}

## Memory

### Memory

### RAM (Random Access Memory)

#### RAM (Random Access Memory)

![RAM](./img/ram.png){width=100%}

### HDD (Hard Disk Drive) / SSD (Solid-State Drive)

#### HDD (Hard Disk Drive) / SSD (Solid-State Drive)

![HDD](./img/SSD.jpeg){width=100%}

![SSD](./img/hdd.png){width=100%}

## Motherboard

### Motherboard

![motherboard](./img/motherboard.jpg){width=100%}

## GPU (Graphical Processing Unit)

### GPU (Graphical Processing Unit)

![GPU](./img/foundation-100046736-orig.jpg){width=100%}

## Alimentation

### Alimentation

![Alim](./img/LD0003357907_2.jpg){width=100%}

---

# Computer model: universal Turing machine

## Computer model: universal Turing machine

![width:20% height:20%](./img/lego_turing_machine.jpg){width=100%}

---

# As simple as a Turing machine ?

## As simple as a Turing machine?

![universal_truing_machine](./img/universal_truing_machine.png){width=100%}

![Universal Turing Machine](./img/universal_truing_machine.png){width=100%}

- A tape divided into cells, one next to the other. Each cell contains a symbol from some finite alphabet.

- A head that can read and write symbols on the tape and move the tape left and right one (and only one) cell at a time.

---

# Basic Input Output System (BIOS)

## Basic Input Output System (BIOS)

> Used to perform hardware initialization during the booting process (power-on startup), and to provide runtime services for operating systems and programs.

- comes pre-installed on a personal computer's system board

- the first software to run when powered on

- in modern PCs initializes and tests the system hardware components, and loads a boot loader from a mass memory device

- Comes pre-installed on a personal computer's system board

- The first software to run when powered on

- In modern PCs, it initializes and tests the system hardware components, and loads a boot loader from a mass memory device

---

# Unified Extensible Firmware Interface (UEFI)

## Unified Extensible Firmware Interface (UEFI)

Advantages:

---

# Operating System (OS)

## Operating System (OS)

> A system software that manages computer hardware, software resources, and provides common services for computer programs.

- The first thing loaded by the BIOS/UEFI

- The first thing on the tape of a Turing machine

## Kernel

### Kernel

> The kernel provides the most basic level of control over all of the computer's hardware devices. It manages memory access for programs in the RAM, it determines which programs get access to which hardware resources, it sets up or resets the CPU's operating states for optimal operation at all times, and it organizes the data for long-term non-volatile storage with file systems on such media as disks, tapes, flash memory, etc.

> The kernel provides the most basic level of control over all of the computer's hardware devices. It manages memory access for programs in the RAM, determines which programs get access to which hardware resources, sets up or resets the CPU's operating states for optimal operation at all times, and it organizes the data for long-term non-volatile storage with file systems on such media as disks, tapes, flash memory, etc.

[Kernel](./img/220px-Kernel_Layout.svg.png){width=100%}

![Kernel](./img/220px-Kernel_Layout.svg.png){width=100%}

---

# UNIX

## UNIX

> Unix is a family of multitasking, multiuser computer operating systems that derive from the original AT&T Unix,

> Unix is a family of multitasking, multiuser computer operating systems that derive from the original AT&T Unix.

[![Unix history](./img/1920px-Unix_timeline.en.svg.png){width=100%}](https://upload.wikimedia.org/wikipedia/commons/b/b5/Linux_Distribution_Timeline_21_10_2021.svg)

- [BSD (Berkeley Software Distribution) variant](https://www.freebsd.org/)

- [GNU/Linux](https://www.kernel.org/)

The philosophy of UNIX is to have a large number of small software which do few things but to them well.

The philosophy of UNIX is to have a large number of small software which do a few things but do them well.

# GNU/Linux

## GNU/Linux

Linux is the name of the kernel which software, to get a full OS, Linux is part of the [GNU Project](https://www.gnu.org/).

Linux is the name of the kernel which, combined with GNU, gives a full OS. Linux is part of the [GNU Project](https://www.gnu.org/).

The GNU with Richard Stallman introduced the notion of Free Software:

The GNU project, with Richard Stallman, introduced the notion of Free Software:

1. The freedom to run the program as you wish, for any purpose.

2. The freedom to study how the program works, and change it so it does your computing as you wish. Access to the source code is a precondition for this.

3. The freedom to redistribute copies so you can help others.

4. The freedom to distribute copies of your modified versions to others. By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.

4. The freedom to distribute copies of your modified versions to others. By doing this, you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.

You can find a [list of software licenses](https://www.gnu.org/licenses/license-list.html)

  Your browser does not support the video tag.

</video>

See this [presentation](https://plmlab.math.cnrs.fr/gdurif/presentation_foss/-/blob/main/presentation/presentation_DURIF_foss.pdf) (in french) for a quick introduction about **software license** and **free/open source software**.

See this [presentation](https://plmlab.math.cnrs.fr/gdurif/presentation_foss/-/blob/main/presentation/presentation_DURIF_foss.pdf) (in french) for a quick introduction about **software licenses** and **free/open source software**.

[Instead of installing GNU/Linux on your computer, you are going to learn to use the IFB Cloud.](./2_using_the_ifb_cloud.html)

---

title: IFB (Institut Français de bio-informatique) Cloud

author: "Laurent Modolo"

output:

  rmdformats::downcute:

    self_contain: true

    use_bookdown: true

    default_style: "light"

    lightbox: true

    css: "./www/style_Rmd.css"

---

```{r include = FALSE}

if (!require("fontawesome")) {

  install.packages("fontawesome")

}

if (!require("klippy")) {

  install.packages("remotes")

  remotes::install_github("rlesur/klippy")

}

library(fontawesome)

knitr::opts_chunk$set(echo = TRUE)

knitr::opts_chunk$set(comment = NA)

klippy::klippy(

  position = c('top', 'right'),

  color = "white",

  tooltip_message = 'Click to copy',

  tooltip_success = 'Copied !')

```

<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">

<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" />

</a>

[![cc_by_sa](./img/cc_by_sa.png)](http://creativecommons.org/licenses/by-sa/4.0/)

Objective: Start and connect to an appliance on the IFB cloud

Instead of working on your computer where you don't have an Unix-like OS or have limited right, we are going to use the [IFB (Institut Français de bio-informatique) Cloud]( https://biosphere.france-bioinformatique.fr/).

# Creating an IFB account

1. Access the [**https://biosphere.france-bioinformatique.fr/**](https://biosphere.france-bioinformatique.fr/) website

2. On the top right (First) steps with GNU/Linux

Instead of working on your computer where you don't have a Unix-like OS or have limited rights, we are going to use the [IFB (Institut Français de bio-informatique) Cloud]( https://biosphere.france-bioinformatique.fr/).

   Instead of working on your computer where you don't have an Unix-like OS or have limited right, we are going to use the [IFB (Institut Français de bio-informatique) Cloud]( https://biosphere.france-bioinformatique.fr/). For this you will need:

## Creating an IFB account

1. Access the [**https://biosphere.france-bioinformatique.fr/**](https://biosphere.france-bioinformatique.fr/) website

   2. On the top right of the screen click on <img src="./img/signin_ifb.png" alt="sign in" style="zoom:150%;" />

   3. Then click on ![login](./img/login_ifb.png)

   4. Use the **Incremental search field** to select your identity provider (CNRS / ENS de Lyon / etc.)

   5. Login

   6. Complete the form with your **Name**, **First Name**, **Town** and **Zip Code**. You can ignore the other field and click on **accept**.

   6. Complete the form with your **Name**, **First Name**, **Town** and **Zip Code**. You can ignore the other fields and click on **accept**.

   7. Go to your **Groups** parameters on the top right ![group_selection_ifb](./img/group_selection_ifb.png)

   8. Click on ![join_a_group](./img/join_a_group.png) and type **LBMC Unix 2022**

   8. Click on ![join_a_group](./img/join_a_group.png) and type **CAN UNIX 2023**

   9. You can click on the **+** sign to register and wait to be accepted in the group

# Starting the LBMC Unix 2022 appliance

## Starting the LBMC Unix 2022 appliance

To follow this practical you will need to start the **[LBMC Unix 2022](https://biosphere.france-bioinformatique.fr/catalogue/appliance/177/)** appliance from the [IFB Cloud](https://biosphere.france-bioinformatique.fr/) and click on the ![start](./img/start_VM.png) button after login with your account.

The ![hourglass](./img/wait_my_appliances_ifb.png) symbol indicates that your appliance is starting.

# Accessing the LBMC Unix 2022

## Accessing the LBMC Unix 2022

You can open the **https** link next to the termination button of your appliance in a new tab. You will have the following message

You can open the **https** link next to the termination button of your appliance in a new tab. You will have the following message.

![ssl warning](./img/ssl_warning.png)

This means that the https connection is encrypted with a certificate unknown to your browser. As this certificate is going to be destroyed when you terminate your appliance, we don't want to pay a certification authority to validate it. Therefore you can safely add an exception for this certificate.

This means that the https connection is encrypted with a certificate unknown to your browser. As this certificate is going to be destroyed when you terminate your appliance, we don't want to pay a certification authority to validate it. Therefore, you can safely add an exception for this certificate.

![ssl exception](./img/ssl_exception.png)

![past from browser](./img/shellinabox_past_from_browser.png)

Then paste your password in the dialog box.

Then, paste your password in the dialog box.

Don't worry the password will not be displayed (not even in the form of `*****`, so someone looking at your screen will not be able to guess it's length), you can press **enter** to log on your VM.

Don't worry the password will not be displayed (not even as `*****`, so someone looking at your screen cannot guess it's length), you can press **enter** to log on your VM.

[First steps in a terminal.](./3_first_steps_in_a_terminal.html)

---

title: First step in a terminal

author: "Laurent Modolo"

output:

  rmdformats::downcute:

    self_contain: true

    use_bookdown: true

    default_style: "light"

    lightbox: true

    css: "./www/style_Rmd.css"

---

```{r include = FALSE}

if (!require("fontawesome")) {

  install.packages("fontawesome")

}

if (!require("klippy")) {

  install.packages("remotes")

  remotes::install_github("rlesur/klippy")

}

library(fontawesome)

knitr::opts_chunk$set(echo = TRUE)

knitr::opts_chunk$set(comment = NA)

klippy::klippy(

  position = c("top", "right"),

  color = "white",

  tooltip_message = "Click to copy",

  tooltip_success = "Copied !"

)

```

<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">

<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" />

</a>

Objective: learn to use basic terminal commands

[![cc_by_sa](./img/cc_by_sa.png)](http://creativecommons.org/licenses/by-sa/4.0/)

Objective: learn to use basic terminal command

Congratulations, you are now connected to your VM!

Congratulations you are now connected on your VM !

The first thing that you can see is a welcome message (yes GNU/Linux users are polite and friendly), and information on your distribution.

The first thing that you can see is a welcome message (yes, GNU/Linux users are polite and friendly), and information on your distribution.

> A **Linux distribution** (often abbreviated as **distro**) is an [operating system](https://en.wikipedia.org/wiki/Operating_system) made from a software collection that is based upon the [Linux kernel](https://en.wikipedia.org/wiki/Linux_kernel)

You can go to this distribution website and have a look at the list of firms using it.

# Shell

## Shell

A command-line interpreter (or shell), is a software designed to read lines of text entered by a user to interact with an OS.

A command-line interpreter (or shell) is a software designed to read lines of text entered by a user to interact with an OS.

To simplify the shell executes the following infinite loop:

1. read a line

2. translate this line as a program execution with its parameters

3. launch the corresponding program with the parameters

3. wait for the program to finish

1. Read a line

2. Translate this line as a program execution with its parameters

3. Launch the corresponding program with the parameters

3. Wait for the program to finish

4. Go back to 1.

When you open a terminal on an Unix-like OS, you will have a **prompt** displayed: it can end with a **$** or a **%** character depending on your configuration. As long as you see your prompt, it means that you are in step **1.**, if no prompt is visible, you are in step **4.** or you have set up a very minimalist configuration for your shell.

When you open a terminal on a Unix-like OS, you will have a **prompt** displayed: it can end with a `$` or a `%` character depending on your configuration. As long as you see your prompt, it means that you are in step **1.**, if no prompt is visible, you are in step **4.** or you have set up a very minimalist configuration for your shell.

<img src="./img/prompt.png" alt="prompt" style="zoom:150%;" />

The blinking square or vertical bar represents your **cursor**. Shell predates graphical interfaces, so most of the time you won’t be able to move this cursor with your mouse, but with the directional arrows (left and right).

The blinking square or vertical bar represents your **cursor**. Shell predates graphical interfaces, so most of the time you won't be able to move this cursor with your mouse, but with the **directional arrows** (left and right).

On the IFB, your prompt is a **$**

On the IFB, your prompt is a `$`:

```sh

etudiant@VM:~$

```

You can identify the following information from your prompt: **etudiant** is your login and **VM** is the name of your VM (**~** is where you are on the computer, but we will come back to that later).

You can identify the following information from your prompt: **etudiant** is your login and **VM** is the name of your VM (`~` is where you are on the computer, i.e. the current working directory, but we will come back to that later).

On Ubuntu 20.04, the default shell is [Bash](https://en.wikipedia.org/wiki/Bash_(Unix_shell)) while on recent version of macOS it’s [zsh](https://en.wikipedia.org/wiki/Z_shell). There are [many different shell](https://en.wikipedia.org/wiki/List_of_command-line_interpreters), for example, Ubuntu 20.04 also has [sh](https://en.wikipedia.org/wiki/Bourne_shell) installed.

On Ubuntu 20.04, the default shell is [Bash](https://en.wikipedia.org/wiki/Bash_(Unix_shell)) while on recent version of macOS it's [zsh](https://en.wikipedia.org/wiki/Z_shell). There are [many different shell](https://en.wikipedia.org/wiki/List_of_command-line_interpreters), for example, Ubuntu 20.04 also has [sh](https://en.wikipedia.org/wiki/Bourne_shell) installed.

# Launching Programs

## Launching Programs

You can launch every program present on your computer from the shell. The syntax will always be the following:

etudiant@VM:~$ program_name option_a option_b option_c [...] option_n

```

And pressing **enter** to execute your command.

And pressing the **Enter** key to execute your command.

For example, we can launch the `cal` software by typing the following command and pressing **enter**:

For example, we can launch the `cal` software by typing the following command and pressing **Enter**:

```sh

cal

- Files can we read or written

- etc.

We can pass argument to the `cal` software the following way.

We can pass an argument to the `cal` software in the following way:

```sh

cal -3

What is the effect of the `-3` parameter?

You can add as many parameters as you want to your command, try `-3 -1` what is the meaning of the `-1` parameter ?

You can add as many parameters as you want to your command. Try `-3 -1`. What is the meaning of the `-1` parameter?

The `-d` option display the month of a given date in a `yyyy-mm` format. Try to display your month of birth.

The `-d` option displays the month of a date given in a `yyyy-mm` format. Try to display your month of birth.

Traditionally, parameters are *named* which means that they are in the form of:

Traditionally, parameters are *named* in one of two ways:

* `-X` for an on/off option (like `cal -3`)

* `-X something` for an input option (like `cal -d yyyy-mm`)

Here the name of the parameter is `X`, but software can also accept list of unnamed parameters. Try the following:

Here, the name of the parameter is `X`, but software can also accept a list of unnamed parameters. Try the following:

```sh

cal 2

cal 2 1999

```

What is the difference for the parameter value `2` in the first and third command ?

What is the difference for the parameter value `2` in the first and third commands?

# Moving around

## Moving around

For the `cal` program, the position in the file system is not important (it’s not going to change the calendar). However, for most tools that are able to read or write files, it’s important to know where you are. This is the first real difficulty with command line interface: you need to remember where you are.

For the `cal` program, the position in the file system is not important (it will not change the calendar). However, for most tools that can read or write files, it's important to know where you are. This is the first real difficulty with the command line interface: **you need to remember where you are**.

If you are lost, you can **p**rint your **w**orking **d**irectory (i.e., where you are now, working) with the command.

pwd

```

Like `cal`, the `pwd` command return textual information

Like `cal`, the `pwd` command returns textual information.

By default when you log on an Unix system, you are in your **HOME** directory. Every user (except one) should have it’s home directory in the `/home/`folder.

By default when you log on a Unix system, you are in your **HOME** directory. Every user (except one) should have its home directory in the `/home/`folder.

To **c**hange **d**irectory you can type the command `cd`, `cd` take one argument: the path of the directory where you want to go. go to the `/home` directory.

To **c**hange **d**irectory you can type the command `cd`. `cd` takes one argument: the path of the directory where you want to go. To go to the `/home` directory you can use:

```sh

cd /home

```

The `cd` command doesn’t return any textual information, but change the environment of the shell (you can confirm it with ` pwd`) ! You can also see this change in your prompt:

The `cd` command doesn't return any textual information, but changes the environment of the shell (you can confirm it with ` pwd`)! You can also see this change in your prompt:

```sh

`etudiant@VM:/home$`

```

What happens when you type `cd` without any argument ?

What happens when you type `cd` with no arguments?

What is the location shown in your prompt? Is it coherent with the `pwd` information? Can you `cd` to the `pwd` path?

When we move around a file system, we often want to see what is in a given folder. We want to **l**i**s**t the directory content. Go back to the `/home` directory and use to the `ls` command see how many people have a home directory there.

When we move around a file system, we often want to see what is in a folder. We want to **l**i**s**t its content. Go back to the `/home` directory and use the `ls` command to see how many users have a home directory there.

We will see various options for the `ls` command, throughout this course. Try the `-a` option.

We will see various options for the `ls` command throughout this course. Try the `-a` option.

```sh

ls -a

cd ..

```

What appended ?

What happened?

Repeat 3 times the previous command (you can use the upper directional arrow to repeat the last command).

Repeat the previous command 3 times (you can use the up arrow key, `↑`, to repeat the last command).

What append ?

What happened?

You can use the `-l` option in combination with the `-a` option to know more about those folders.

---

title: GNU/Linux file system

author: "Laurent Modolo"

output:

  rmdformats::downcute:

    self_contain: true

    use_bookdown: true

    default_style: "light"

    lightbox: true

    css: "./www/style_Rmd.css"

---

```{r include = FALSE}

if (!require("fontawesome")) {

  install.packages("fontawesome")

}

if (!require("klippy")) {

  install.packages("remotes")

  remotes::install_github("rlesur/klippy")

}

library(fontawesome)

knitr::opts_chunk$set(echo = TRUE)

knitr::opts_chunk$set(comment = NA)

klippy::klippy(

  position = c("top", "right"),

  color = "white",

  tooltip_message = "Click to copy",

  tooltip_success = "Copied !"

)

```

<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">

<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" />

</a>

[![cc_by_sa](./img/cc_by_sa.png)](http://creativecommons.org/licenses/by-sa/4.0/)

Objective: Understand how files are organized in Unix

> On a UNIX system, everything is a file; if something is not a file, it is a process.

We can also access files with a **relative path**, using the special folder `..`. From your home folder, go to the *ubuntu*  user home folder without passing by the root (we will see use of the  `.` folder later).

# File Types

## File Types

As you may have guessed, every file type is not the same. We have already seen that common file and folder are different. Here is the list of file types:

ls -la

```

The first column will tell you the type of the file (here we have only the type `-` and `d`). We will come back on the other information later. Another less used command to get fine technical information on a file is the command `stat [file_name]`. Can you get the same information as `ls -la` with `stat` ?

The first column will tell you the type of the file (here we have only the types `-` and `d`). We will come back to the other types later. Another less-used command to get fine technical information on a file is the command `stat [file_name]`. Can you get the same information as `ls -la` with `stat`?

# Common Structure

## Common Structure