---
# System prepended metadata

title: Cap1 - Art 2 - Instalando o ROS
tags: [Apostila de Introdução Geral no LEAD - 2024]

---

# Capítulo 1 - Artigo 2 - Instalando o ROS

> Via Conteinerização

## 2.0 - Introdução 

Como foi dito antes, existem muitos ROS diferentes, um para cada versão de ubuntu, python e outras dependências diferentes. 
Existem 3 formas de lidar com isso. Uma é escolhendo uma distro e instalando um sistema pensando nela, outra é descobrir qual versão de ROS atua na distro que você está usando, e por último você pode usar multiplos sistemas operacionais para cada ROS.
Eu vou falar sobre a terceira forma. Se você quer instalar uma versão específica, você pode entrar no site do ROS e procurar o passo a passo da instalação. 
A proposta desse artigo é diferente. A ideia é usar uma tecnologia chamada de container para você conseguir usar qualquer ROS no seu sistema, sem ter que se preocupar com a versão das dependencias do ROS no seu computador.

## 2.0.1 - Sumário Geral do capitulo 1
1. Introdução do Capítulo 
2. Instalando o ROS   < Estamos aqui
3. Nó
4. Publicador
5. Subscritor
6. Raspberry Pi
7. Nó Raspberry
8. Launch

## 2.0.2 Sumário Local
[TOC]

## 2.1 Conteinerização Vs Virtualização

Máquinas virtuais são simulações de uma máquina física. Assim você instala um sistema operacional dentro dessa máquina simulada. Existem diversos programas que fazem isso, um deles é o [virtual box](https://www.virtualbox.org/).
Um container compartilha várias instâncias do sistema operacional e não virtualiza uma máquina. Basicamente um container é a execução de um sistema operacional gerenciado pelo seu sistema operacional. Ele é como se você pegasse o [ubuntu](https://ubuntu.com/) e mandasse ele rodar o [fedora](https://fedoraproject.org/). 
Containers geralmente são orientados a aplicações. Vou dar um exemplo simplificado para elucidar isso.

Vamos dizer que você desenvolveu um programa no ubuntu usando python3.10 e você quer rodar num fedora que tem o python3.3. Como você faria? Bom, você poderia criar uma imagem do ubuntu com o python3.10 e o seu programa.

Depois você passa essa imagem para o podman que vai criar um container dentro do fedora. O fedora irá executar esse container, e quando o programa dentro desse container executar uma chamada no python, irá chamar o python 3.10 dentro do container, e não o python 3.3 do fedora.

![container2](https://hackmd.io/_uploads/HJ0jQPC26.png)

## 2.2 Podman

O Podman é um programa para criar e gerenciar seus containers, assim como o docker. Usaremos o podman nessa apostila.

Instalando o podman.
```bash
user@host:~$ sudo apt update
user@host:~$ sudo apt upgrade -y
user@host:~$ sudo apt install podman -y
```

Quando falamos de containers existem diversos conceitos que são necessários a apropriação, como imagens, containers, hosts, nodes, volumes e containerfiles.
O Podman usa imagens para construir containers. Tambêm é possível o contrário.
Containers são esses espaços sendo executados pelo linux. Imagens são arquivos que o podman usa para construir esses containers. Basicamente imagens são arquivos de um sistema operacional e programas.
O ubuntu por exemplo, pode ser comprimido para um arquivo de imagem. Fazendo isso eu posso usar o podman para criar um container com essa imagem.
Quando você vai iniciar um container, você informa pro podman qual imagem você quer usar.
Um containerfile é um arquivo (como o dockerfile) texto que você vai passar pro podman onde ele irá criar uma imagem a partir de outra imagem. Normalmente você inicia falando qual imagem você quer e quais mudanças você quer fazer nela.
Pegando nosso exemplo você poderia criar um containerfile onde você falaria que você quer usar o ubuntu e que quer instalar o python3.10 nele, que tenha a sua aplicação e execute ela quando for iniciado.
Com esse containerfile vc poderia criar uma imagem com o podman. Com todas as pessoas que você compartilhar essa imagem, elas poderão executar sua aplicação, independente da distribuição linux que elas usarem.
Quando um computador executa o podman para iniciar um conteiner a partir de uma imagem esse computador será chamado de host. Esse conteiner será chamado de node. É possível levantar vários conteiners a partir da mesma imagem.
Esses conteiners são volateis, quando você executa um conteiner e ele executa algo que modifica alguma informação (salva um arquivo pdf em seu diretório home por exemplo), quando esse conteiner for desligado, as informações serão perdidas. Por isso dizemos que são volateis.
Se você deseja salvar alguma informação é necessário que você crie volumes.
Volumes são diretórios do host linkados com o node que você linka na hora que você constrói o node. Assim, o node verá como um diretório normal dentro dele e sempre que ele mexer nesse espaço, ele irá mexer com o diretório linkado.
```bash
-v dir/do/host:dir/do/node
```

## 2.4 DistroBox

Instalando o Distrobox:

```bash
user@host:~$ curl https://raw.githubusercontent.com/89luca89/distrobox/main/install | sudo sh
```

Criando um container com o distroBox e entrando nele

```bash
user@host:~$ mkdir -p ~/distroboxContainers/humbleV1
user@host:~$ distrobox-create --root --image docker.io/library/ros:humble-ros-base-jammy --name humbleV1 --home ~/distroboxContainers/humbleV1
```  

\- O comando acima cria uma imagem. As flags serão descritas abaixo:

- --root: instala como root
- --image: pega uma imagem específica para criar a nova imagem. Isso
  pode ser feito localmente ou busca da internet, fazendo um pull do
  docker hub. No caso estou pegando a imagem do docker-hub,
  humble-ros-base-jammy
- --name: específica um nome para a imagem. Isso é importante para
  referenciar de forma scriptável, porque se não especificar, será dado um
  nome aleatório.
- –home: conecta um diretório do host com a home da imagem usando a
  tecnologia de volumes. É necessário que o diretório exista antes.


- Levantando um container usando a imagem criada.

```bash
user@host:~$ distrobox enter --root humbleV1
user@humbleV1:~$ cd ~
user@humbleV1:~$ sudo apt update | sudo apt upgrade -y  
```

## 2.5 Instalação do ROS dentro de um container usando o Distrobox

Instalando o ROS no container

```bash
user@humbleV1:~$ sudo apt install software-properties-common  
user@humbleV1:~$ sudo add-apt-repository universe
user@humbleV1:~$ sudo apt update | sudo apt upgrade -y  
user@humbleV1:~$ sudo apt install ros-humble-desktop  
user@humbleV1:~$ sudo apt install ros-humble-ros-base ros-dev-tools python3-pip 
```

- Instalando o colcon, o build que você usará para construir seus pacotes no ROS: 

```bash
~$ sudo apt install python3-colcon-common-extensions  
```

[documentação do colcon](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Colcon-Tutorial.html)

```bash
~$ pip3 install setuptools==58.2.0 
user@humbleV1:~/ros2_ws$ pip3 install pynput
~$ sudo apt install ros-humble-gazebo-ros-pkgs
```

- Com isso você já está pronto para usar o ROS no seu container.