Mudanças entre as edições de "PJI2-2018-1"
(65 revisões intermediárias por 4 usuários não estão sendo mostradas) | |||
Linha 1 990: | Linha 1 990: | ||
# Qual a nova máscara de sub-rede (0,5 ponto)? | # Qual a nova máscara de sub-rede (0,5 ponto)? | ||
# Listar a faixa de endereços de cada sub-rede (1 ponto). | # Listar a faixa de endereços de cada sub-rede (1 ponto). | ||
+ | |||
<!--Para responder a questão da letra a, você deve lembrar da fórmula: | <!--Para responder a questão da letra a, você deve lembrar da fórmula: | ||
Linha 2 141: | Linha 2 142: | ||
mayara.sousa@ifsc.edu.br | mayara.sousa@ifsc.edu.br | ||
+ | |||
+ | Leituras úteis: | ||
+ | |||
+ | * [http://www.dltec.com.br/blog/redes/tecnica-4-em-1-para-analise-de-endereco-ip/ Técnica 4 em 1 para análise de endereço IP] | ||
</font> | </font> | ||
Linha 2 658: | Linha 2 663: | ||
{{Collapse bottom | Aula 19}} | {{Collapse bottom | Aula 19}} | ||
− | =25/04/2018: | + | =25/04/2018: Preparando um computador= |
{{Collapse top | Aula 20}} | {{Collapse top | Aula 20}} | ||
Linha 2 668: | Linha 2 673: | ||
− | + | Nas aulas anteriores fizemos um aquecimento, em que instalamos um sistema operacional em uma máquina virtual. Hoje iremos repetir essa tarefa, porém usando um computador real. Assim a primeira parte do projeto 2 pode ser mais realista, simulando uma situação corriqueiramente enfrentada na prática. | |
== Obtendo o computador == | == Obtendo o computador == | ||
Linha 2 677: | Linha 2 682: | ||
* [http://www-03.ibm.com/ibm/history/exhibits/mainframe/mainframe_album.html Fotos de antigos computadores] | * [http://www-03.ibm.com/ibm/history/exhibits/mainframe/mainframe_album.html Fotos de antigos computadores] | ||
* [http://www.extremetech.com/computing/92640-ibm-personal-computer-its-30-year-legacy-slideshow 30 anos do PC IBM] | * [http://www.extremetech.com/computing/92640-ibm-personal-computer-its-30-year-legacy-slideshow 30 anos do PC IBM] | ||
− | + | * [https://ark.intel.com/compare/97466,97541 Comparativo entre processadores] | |
+ | * [https://ark.intel.com/ Link Intel especificações] | ||
+ | * [https://www.baboo.com.br/arquivo/hardware/entenda-quais-sao-os-tipos-de-raid/ Tipos de RAID] | ||
[[imagem:Pji1-Computer_from_inside.jpg|600px]] | [[imagem:Pji1-Computer_from_inside.jpg|600px]] | ||
Linha 2 700: | Linha 2 707: | ||
|- | |- | ||
|rowspan=9| 1 ||Processador || || | |rowspan=9| 1 ||Processador || || | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
|- | |- | ||
|HD || || | |HD || || | ||
Linha 2 762: | Linha 2 733: | ||
* [http://www.youtube.com/watch?v=Y7U8M6UsEwE&feature=related Funcionamento de um disco rígido] | * [http://www.youtube.com/watch?v=Y7U8M6UsEwE&feature=related Funcionamento de um disco rígido] | ||
* [http://www.youtube.com/watch?v=kdmLvl1n82U Outro video sobre funcionamento de um disco rígido] | * [http://www.youtube.com/watch?v=kdmLvl1n82U Outro video sobre funcionamento de um disco rígido] | ||
+ | |||
+ | ==Exercícios== | ||
+ | |||
+ | Os conceitos e termos técnicos vêm se acumulando gradativamente. Como exercício de compreensão, explique o que significa: | ||
+ | * sistema operacional | ||
+ | * partição | ||
+ | * sistema de arquivos | ||
+ | * particionamento manual | ||
+ | * partição raiz | ||
+ | * memória virtual | ||
+ | * memória RAM | ||
+ | * backup | ||
+ | * disco rígido (HD) | ||
+ | * placa de video | ||
+ | * monitor | ||
+ | * computador | ||
+ | * programas | ||
+ | * CPU (processador) | ||
+ | |||
+ | === Exercício === | ||
+ | |||
+ | ---- | ||
+ | |||
+ | Você recebeu a tarefa de especificar um computador a ser comprado em sua empresa. Esse computador deve ser usado para rodar programas de escritório. A empresa optou por adquirir os componentes em separado, de forma a montar o computador. Sendo assim, '''selecione todos os componentes desse computador''', informando fabricante, modelo e preço. Use componentes disponíveis em mercado atualmente. Inclua figuras para ilustrar as peças do computador que você escolheu ('''Avaliação em aula'''). | ||
+ | |||
+ | |||
+ | </font> | ||
+ | {{Collapse bottom | Aula 20}} | ||
+ | |||
+ | =26/04/2018: Utilizando Raspberry Pi= | ||
+ | |||
+ | {{Collapse top | Aula 21}} | ||
+ | <font size="3"> | ||
+ | |||
== Uso de RaspberryPi como computador == | == Uso de RaspberryPi como computador == | ||
Linha 2 769: | Linha 2 774: | ||
[[imagem:PJI2-Raspberry-Pi-3.jpg|600px]] | [[imagem:PJI2-Raspberry-Pi-3.jpg|600px]] | ||
− | <br>'' | + | <br>''Raspbere utilizando Raspberry PiryPi 3'' |
Linha 2 788: | Linha 2 793: | ||
# Inicie sua máquina virtual. Os comandos a seguir devem ser feitos nessa máquina virtual. | # Inicie sua máquina virtual. Os comandos a seguir devem ser feitos nessa máquina virtual. | ||
# Na área de trabalho devem aparecer dois discos USB: ejete-os clicando sobre cada um deles co o botão direito do mouse e selecionando ''Ejetar'' | # Na área de trabalho devem aparecer dois discos USB: ejete-os clicando sobre cada um deles co o botão direito do mouse e selecionando ''Ejetar'' | ||
− | # Obter a [http://curl.sj.ifsc.edu.br/~msobral/rpi/ imagem do sistema operacional] ([http://191.36.9.102/~msobral/rpi/ link alternativo]) | + | # Obter a [http://curl.sj.ifsc.edu.br/~msobral/rpi/ imagem do sistema operacional] ([http://191.36.9.102/~msobral/rpi/ link alternativo 1]) ([https://ubuntu-mate.org/raspberry-pi/ubuntu-mate-16.04.2-desktop-armhf-raspberry-pi.img.xz Link alternativo 2]). |
# Descompactar a imagem (note que ela possui a extensão ''.xz'' ... na dúvida, ver a [[Manipulação_de_arquivos_e_diretórios#Compactadores_no_modo_texto|aula sobre compactadores]]) | # Descompactar a imagem (note que ela possui a extensão ''.xz'' ... na dúvida, ver a [[Manipulação_de_arquivos_e_diretórios#Compactadores_no_modo_texto|aula sobre compactadores]]) | ||
# Abra um terminal e nele execute: <syntaxhighlight lang=bash> | # Abra um terminal e nele execute: <syntaxhighlight lang=bash> | ||
Linha 2 795: | Linha 2 800: | ||
# Ao final, encerre a máquina virtual. Seu cartão microSD está preparado. | # Ao final, encerre a máquina virtual. Seu cartão microSD está preparado. | ||
− | |||
− | + | Leitura útil: | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | ---- | + | * [http://www.blogporta80.com.br/2010/11/02/linux-trabalhando-com-o-comando-scp/ Trabalhando com o comando scp] |
− | + | === Exercício === | |
− | |||
− | |||
− | === Exercício | ||
---- | ---- | ||
Linha 2 830: | Linha 2 816: | ||
* Criar o usuário principal com o nome de '''PJI2''' e senha '''pji2'''; | * Criar o usuário principal com o nome de '''PJI2''' e senha '''pji2'''; | ||
* Criar os seguintes grupos: '''academicos''' e '''docentes'''; | * Criar os seguintes grupos: '''academicos''' e '''docentes'''; | ||
− | * Crie em '''/home'' dois diretórios: '''academicos''' e '''docentes'''; | + | * Crie em '''/home''' dois diretórios: '''academicos''' e '''docentes'''; |
* Criar os seguintes usuários: '''alunos''', '''professores''' e '''monitores'''. O usuário '''alunos''' deverá ter o seu diretório padrão em '''/home/academicos''' e os usuários '''professores''' e '''monitores''' devem ter seu diretório padrão em '''/home/docentes'''; | * Criar os seguintes usuários: '''alunos''', '''professores''' e '''monitores'''. O usuário '''alunos''' deverá ter o seu diretório padrão em '''/home/academicos''' e os usuários '''professores''' e '''monitores''' devem ter seu diretório padrão em '''/home/docentes'''; | ||
* Dê as permissões de leitura e gravação para os usuários de cada grupo e nenhuma permissão para os demais usuários destes diretórios; | * Dê as permissões de leitura e gravação para os usuários de cada grupo e nenhuma permissão para os demais usuários destes diretórios; | ||
+ | * Configure um servidor FTP com as seguintes definições: | ||
+ | ** O diretório de acesso de todos os usuários deve ser '''/srv/ftp/media''' | ||
+ | ** O grupo de acesso dos usuários do servidor FTP deve ser '''ftpgroup''' | ||
+ | ** Deve ser criado um usuário chamado '''userftp''', sem acesso ao terminal, e acesso somente ao diretório '''/srv/ftp/media''', para o acesso ao servidor FTP | ||
+ | ** Os usuários '''professores''' e '''monitores''' também devem ter acesso ao servidor FTP no diretório '''/srv/ftp/media'''. | ||
+ | * Configure também um servidor SSH onde o root não pode ter acesso. | ||
+ | * Use o comando '''scp''' para copiar arquivos de outros Raspberrys da rede. | ||
+ | |||
+ | |||
+ | |||
+ | Leituras úteis: | ||
+ | |||
+ | * [http://www.blogporta80.com.br/2010/11/02/linux-trabalhando-com-o-comando-scp/ Trabalhando com o comando scp] | ||
+ | |||
+ | * [https://bobcares.com/blog/proftpd-530-login-incorrect-error/ How to fix Proftpd ‘530 login incorrect’ error in web hosting servers] | ||
+ | </font> | ||
+ | {{Collapse bottom | Aula 21}} | ||
+ | |||
+ | =02/05/2018: Utilizando Raspberry Pi - Continuação= | ||
+ | |||
+ | {{Collapse top | Aula 22}} | ||
+ | <font size="3"> | ||
+ | |||
+ | |||
+ | </font> | ||
+ | {{Collapse bottom | Aula 22}} | ||
+ | |||
+ | =03/05/2018: Redes sem fio= | ||
+ | |||
+ | {{Collapse top | Aula 23}} | ||
+ | <font size="3"> | ||
+ | |||
+ | |||
+ | == Rede local sem-fio padrão IEEE 802.11 (WiFi) == | ||
+ | |||
+ | Uma rede local sem-fios (WLAN - Wireless Local Area Network) serve para conectar dispositivos usando sinal de rádio. Hoje em dia estão tão difundidas que não se imagina um lugar sem cobertura por ao menos uma dessas redes, cuja tecnologia se chama WiFi (ou [http://tele.sj.ifsc.edu.br/~msobral/RCO2/docs/ieee/802.11-2007.pdf IEEE 802.11], nome oficial do padrão). As pessoas as utilizam para conectar seus smartphones e tablets, além de laptops e mesmo equipamentos diversos ([http://produto.mercadolivre.com.br/MLB-564886491-internet-box-tv-smart-multilaser-android-wifi-hdmi-usb-sd-_JM media centers], [http://olhardigital.uol.com.br/video/qual-e-a-melhor-impressora-wi-fi-do-momento/30117 impressoras], [http://cameras.about.com/od/reviews/tp/best-wi-fi-cameras.htm câmeras fotográficas],[http://www.techradar.com/news/television/6-best-smart-tv-platforms-in-the-world-today-1120795 TVs], e mesmo [http://stations.windguru.cz/intro.php estações meteorológicas], entre outros). Todos esses dispositivos fazem uso de uma infraestrutura relativamente simples. | ||
+ | |||
+ | |||
+ | Uma WLAN é implantada usando um equipamento especial chamado de ponto-de-acesso (AP - ''Access Point''). Um AP transmite periodicamente (10 vezes por segundo) uma pequena mensagem que informa os dispositivos ao redor sobre o nome da rede sem-fio por ele controlada. O alcance típico do sinal do AP é de algumas dezenas de metros. Assim, dispositivos que recebam essa mensagem (chamada de ''beacon'') podem vir a saber que existe essa rede, e se conectarem a ela. Uma vez conectado, um dispositivo pode se comunicar por intermédio do AP. Como usualmente um AP é instalado de forma a estar conectado a uma LAN, os dispositivos a ele conectados podem se comunicar também com a Internet. A figura abaixo ilustra uma pequena WLAN com seu AP provendo conectividade a dispositivos sem-fio, além de estar conectado a um switch de uma LAN. | ||
+ | |||
+ | [[imagem:Pji1-projeto2.png|500px]] | ||
+ | |||
+ | |||
+ | Várias gerações das redes WiFi já foram lançadas, e cada nova geração aumenta significativamente a taxa de transmissão máxima da rede. Atualmente (geração IEEE 802.11ac) essas redes conseguem se comunicar a taxas de transmissão de até 1.3 Gbps. Isso depende do modelo do AP e das interfaces de rede dos dispositivos que usam a rede sem-fio. Na prática, a taxa de transmissão que um dispositivo consegue, no máximo, é um pouco menor que a metade da taxa nominal (ex: para uma rede a 300 Mbps, essa taxa deve ser pouco superior a 100 Mbps). Se houver mais dispositivos, essa taxa de transmissão cai ainda mais, pois eles precisarão compartilhar o canal de comunicação com o AP. Porque isso acontece será visto mais tarde no curso. Por curiosidade, a tabela abaixo mostra as taxas de transmissão máximas das diferentes gerações das redes WiFi. | ||
+ | |||
+ | {| border=1 | ||
+ | !Geração | ||
+ | !Ano de lançamento | ||
+ | !Taxa de transmissão máxima | ||
+ | |- | ||
+ | |IEEE 802.11 || 1997 || 2 Mbps | ||
+ | |- | ||
+ | |IEEE 802.11b || 1999 || 11 Mbps | ||
+ | |- | ||
+ | |IEEE 802.11a || 2000|| 54 Mbps | ||
+ | |- | ||
+ | |IEEE 802.11g || 2003 || 54 Mbps | ||
+ | |- | ||
+ | |IEEE 802.11n || 2009 || 600 Mbps | ||
+ | |- | ||
+ | |IEEE 802.11ac || 2013 || 1.3 Gbps | ||
+ | |} | ||
+ | |||
+ | |||
+ | Uma WLAN possibilita que qualquer dispositivo no alcance do sinal do AP possa a ele se conectar. Isso tem um porém, pois pessoas podem usar indevidamente uma rede sem-fio. Para evitar esse mau-uso, as WLANs possuem um modo de segurança, sendo WPA2-PSK (ou WPA-PSK, WPA Personal, WPA Pessoal) o recomendado para pequenas redes. Basicamente pode-se fazer com que: | ||
+ | * somente pessoas que conheçam uma determinada senha tenham acesso à rede | ||
+ | * todas as comunicações da rede sem-fio sejam encriptadas (protegidas). Com isso se alguém estiver monitorando as transmissões de uma rede sem-fio (e isso é muito fácil de fazer !), não conseguirá entender nada. | ||
+ | |||
+ | Resumindo, para instalar um AP é necessário configurar os seguintes parâmetros: | ||
+ | * '''SSID (nome da rede):''' um breve texto com o nome da rede | ||
+ | * '''Canal:''' o canal de comunicação, parecido com os canais das estações de rádio. Pode haver mais de um AP no mesmo canal, porém quanto mais dispositivos se comunicam por um canal, menor a velocidade da rede por eles percebida. | ||
+ | * '''Segurança:''' WPA2-PSK, com uma senha que deve ter no mínimo 8 caracteres. Recomenda-se que essa senha seja aleatória (ou não seja uma palavra que possa ser deduzida por quem tente invadir sua rede). | ||
+ | |||
+ | Experimente investigar os parâmetros de um AP de verdade usando este emulador: | ||
+ | * [https://www.tp-link.com/resources/simulator/ArcherC73.0(US)/Index.htm TP-Link Archer C7] | ||
+ | |||
+ | |||
+ | Assim, para instalar uma nova rede sem-fio, basicamente deve-se usar um AP. Ele deve ser conectado a uma rede cabeada para ter acesso a Internet. Por fim, o AP precisa ser devidamente configurado para denominar a rede por ele criada, e também o modo de segurança para uso da rede sem-fio. | ||
+ | |||
+ | <div style="text-align: center;">[[Arquivo:rede24ghz.jpg]]</div><br/> | ||
+ | |||
+ | |||
+ | <div style="text-align: center;">[[Arquivo:rede5ghz.jpg]]</div><br/> | ||
+ | |||
+ | |||
+ | Link úteis: | ||
+ | |||
+ | * [https://webpovoa.com/entenda-os-principais-padroes-ieee-802-11/ Entenda os principais padrões IEEE 802.11] | ||
+ | |||
+ | * [https://www.dmesg.com.br/wifi-2-ghz-vs-5-ghz-diferencas-aplicacoes-e-problemas/ WiFi 2 e 5 Ghz, diferenças, aplicações e problemas] | ||
+ | |||
+ | * [https://pplware.sapo.pt/tutoriais/networking/melhor-canal-wireless-5ghz-router/ Qual o melhor canal wireless nos 5GHz para o meu router?] | ||
+ | |||
+ | * [https://www.netspotapp.com/pt/wifi-encryption-and-security.html Protocolos de Segurança de Rede Sem Fio: WEP, WPA e WPA2] | ||
+ | |||
+ | </font> | ||
+ | {{Collapse bottom | Aula 23}} | ||
+ | |||
+ | =09/05/2018: Rotas= | ||
+ | |||
+ | {{Collapse top | Aula 24}} | ||
+ | <font size="3"> | ||
+ | |||
+ | [https://avaliacao.ifsc.edu.br/ Avaliação do Docente] | ||
+ | |||
+ | |||
+ | Como visto anteriormente, cada dispositivo em uma rede precisa ter um endereço IP para que possa se comunicar com outros dispositivos. Porém isso não é suficiente: os dispositivos devem saber que '''direção''' devem enviar mensagens para que cheguem até cada outro dispositivo. Se o dispositivo de destino estiver na mesma rede, então basta transmitir o pacote a ele diretamente. Mas e se ele estiver em outra rede ? Por exemplo, e se um computador no laboratório de Redes 1 quiser se comunicar com outro que está na reitoria do IFSC ? Como esse pacote deve ser transmitido nesse caso? | ||
+ | |||
+ | |||
+ | [[imagem:Pji-projeto2-rotas.png|500px]] | ||
+ | |||
+ | |||
+ | Antes de prosseguir na investigação desse assunto, é necessário uma visão geral sobre redes de computadores e a Internet. Isso deve ajudar a entender como as comunicações acontecem nessa grande rede. | ||
+ | * [[Comunica%C3%A7%C3%A3o_de_dados|Comunicação de dados e a Internet]] | ||
+ | |||
+ | |||
+ | No diagrama que mostra simplificadamente a rede do projeto 2, a rede externa é representada como uma nuvem. Isso significa que sua estrutura interna é desconhecida, ou não é relevante mostrá-la. No caso da Internet, na verdade seria impossível apresentar toda sua estrutura, pois essa rede hoje em dia é gigantesca, além de estar sempre em mutação. Mas ao menos um esboço da rede do Ifsc pode ser apresentado, como se pode ver a seguir. Ao visualizá-la, deve-se novamente imaginar como é possível encaminhar pacotes através dela, de forma que cheguem a seus destinos. | ||
+ | |||
+ | |||
+ | [[imagem:Ifsc.png|600px]] | ||
+ | <br>''Uma visão geral da rede do Ifsc (e bem simplificada !)'' | ||
+ | |||
+ | |||
+ | Em primeiro lugar, deve-se imaginar como a Internet está implantada (ao menos do ponto de vista das subredes). A palavra ''internet'' significa ''rede composta por redes'', e, no caso da ''Internet'', cada uma das redes que a constitui é chamada de [http://pt.wikipedia.org/wiki/Sub-rede ''subrede'']. Se alguém pudesse ver o mapa da Internet, pareceria uma grande malha, com milhares de fios (enlaces) se entrelaçando. Nas junções desses fios estão equipamentos que '''roteiam''' (''direcionam'') pacotes a seus destinos. Os equipamentos finais, que são usados por pessoas para rodas os aplicativos de rede, estão na borda de toda essa malha ... nas pontas dos fios. No fim, isso parece um grande mapa, e como tal ele pode ser percorrido por um ou mais caminhos para se ir de um ponto a outro. | ||
+ | |||
+ | |||
+ | {| border=0 | ||
+ | !''Um mapa da Internet (bem abstrato ...)'' | ||
+ | !Rede Ipê: a Rede Nacional de Pesquisa que originou a Internet no Brasil | ||
+ | |- | ||
+ | |[[imagem:Internet-map.png|600px]] || [[imagem:Rede-ipe-2014.jpg|600px]] | ||
+ | |} | ||
+ | |||
+ | |||
+ | Essa analogia do mapa pode ser experimentada usando o [http://maps.google.com Google Maps]. Experimente traçar caminhos entre o IFSC-SJ e vários destinos (mesmo em outras cidades), e visualize como ele descobre o caminho. Observe também que critério é usado para escolher o caminho ... pois é normal que exista mais de uma opção. | ||
+ | |||
+ | Mas o que isso tem a ver com redes ? Muita coisa: a forma com que o Google Maps descobre caminhos se baseia nos mesmos conceitos usados para descobrir '''rotas''' entre dispositivos na Internet. E voltando a redes de computadores, também é possível descobrir que caminho os pacotes percorrem para ir de um ponto a outro na Internet. | ||
+ | |||
+ | '''Experimento:''': use o programa [http://manpages.ubuntu.com/manpages/hardy/man8/traceroute-nanog.genuine.8.html traceroute] para descobrir os caminhos percorridos por seus pacotes. Teste-o com vários possíveis destinos: | ||
+ | * www.ufsc.br | ||
+ | * www.unicamp.br | ||
+ | * www.brasil.gov.br | ||
+ | * www.nasa.gov | ||
+ | * english.pravda.ru | ||
+ | * www.china.org.cn | ||
+ | * finland.fi | ||
+ | |||
+ | O que significam as informações mostradas por esse programa ? | ||
+ | |||
+ | |||
+ | Estes outros aplicativos descobrem rotas e as mostram sobre um mapa mundial. | ||
+ | * [http://traceroute.monitis.com/ Visual Trace Route Tool (EUA)] | ||
+ | * [http://www.yougetsignal.com/tools/visual-tracert/ Visual Traceroute (EUA)] | ||
+ | * [http://en.dnstools.ch/visual-traceroute.html Traceroute on a map (Alemanha)] | ||
+ | |||
+ | == Rotas no Linux == | ||
+ | |||
+ | Cada computador ligado a Internet possui uma '''tabela de rotas'''. É por meio de tal tabela que ele sabe como transmitir os pacotes para cada destino. Em seu computador, você pode visualizar essa tabela da seguinte forma: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | # Isto funciona em qualquer *nix que se preze ... | ||
+ | netstat -rn | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | Ao se configurar uma interface de rede, cria-se uma rota automática para a subrede diretamente acessível via aquela interface. Isto se chama '''''roteamento mínimo'''''. Por exemplo, se uma interface de rede foi configurada com o endereço IP 192.168.10.1/16, sua tabela de rotas pode se apresentar assim: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | aluno@M1:~> ifconfig eth1 192.168.10.1 netmask 255.255.0.0 | ||
+ | aluno@M1::~> netstat -rn | ||
+ | Kernel IP routing table | ||
+ | Destination Gateway Genmask Flags MSS Window irtt Iface | ||
+ | 192.168.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth1 | ||
+ | 127.0.0.0 0.0.0.0 255.0.0.0 U 0 0 0 lo | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | Usualmente, é suficiente definir uma única rota adicional para um computador, chamada de '''rota default''' (ou ''rota padrão''). Essa rota tem o seguinte significado: se o destino não estiver em minha própria subrede, e nenhuma outra rota específica existir para a subrede onde se encontra, então repasse o pacote para o roteador indicado. Em um computador Linux isso pode ser feito assim: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | # adiciona a rota default, que passa pelo roteador 192.168.10.100 | ||
+ | route add default gw 192.168.10.100 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | Outra forma de adicionar essa rota é: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | # este comando tem o mesmo efeito que o anterior ... | ||
+ | route add -net 0.0.0.0/0 gw 192.168.10.100 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | Por fim, uma rota para um destino qualquer pode ser feita assim (supondo que a rede de destino seja 191.36.9.0/24): | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | # este comando define que para chegar à rede 191.36.9.0/24 | ||
+ | # deve-se usar o gateway 192.168.1.1 | ||
+ | route add -net 191.36.9.0/24 gw 192.168.1.1 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | Isso não parece complicado, e à primeira vista realmente não é :-) Ao se instalar um novo equipamento em uma rede, seja um computador, tablet, ponto de acesso ou smart TV, basta configurá-lo com a rota ''default'' para que possa se comunicar com a Internet. Na verdade, nem isso normalmente é necessário, pois esses equipamentos são capazes de se autoconfigurarem como mágica (mais tarde veremos como !). Porém existe uma matemática interessante por trás de como essas rotas funcionam, e vale dar uma olhada. | ||
+ | |||
+ | === Rotas, prefixos de rede e máscaras === | ||
+ | |||
+ | Uma rota serve para informar como se chega a um determinado destino. Um destino pode ser um único endereço IP, ou uma subrede (que contém um conjunto de endereços IP). Para que um pacote IP chegue a um destino, deve-se transmiti-lo para o próximo roteador em direção a esse destino. Esse próximo roteador também deve conhecer uma rota para tal destino, repetindo o mesmo processo (reveja o experimento com '''traceroute''). Ao menos duas informações compõem cada rota: | ||
+ | * '''O próximo roteador, expressado por um endereço IP:''' o endereço IP do próximo roteador (também chamado de ''gateway'', que significa ''portal'' em inglês), o qual deve pertencer à mesma subrede do equipamento que o especifica em uma rota. | ||
+ | * '''O destino, que é expressado como uma subrede:''' Uma subrede é representada por um ''prefixo de rede'' e uma ''máscara''. O prefixo são os ''N'' bits mais significativos comuns a todos os endereços IP contidos em uma subrede (lembre que um endereço IP tem 32 bits). A máscara informa quantos bits tem o prefixo. A combinação de prefixo de rede e máscara funciona da seguinte forma: | ||
+ | |||
+ | Imagine que exista uma subrede contendo os endereços de 192.168.2.0 até 192.168.2.255. Se representarmos esses endereços em binário, podemos ver que os 24 bits mais significativos são os mesmos para todos os endereços: | ||
+ | |||
+ | |||
+ | [[imagem:Pji-prefixo1.png|400px]] | ||
+ | |||
+ | |||
+ | A máscara de rede tem a forma de um endereço IP, porém com bits 1 na parte correspondente ao prefixo, e 0 no resto. Assim, para o exemplo acima a máscara de rede é ''255.255.255.0''. Outra forma de representar a máscara é simplesmente informar o tamanho em bits do prefixo, e no exemplo a máscara seria ''24''. Juntando o prefixo e a máscara, a subrede pode ser representada de uma destas duas formas: | ||
+ | * '''192.168.2.0/255.255.255.0''' | ||
+ | * '''192.168.2.0/24''' | ||
+ | |||
+ | |||
+ | Agora imagine que o prefixo tenha 28 bits, como mostrado nesta figura: | ||
+ | |||
+ | |||
+ | [[imagem:Pji-prefixo2.png|400px]] | ||
+ | |||
+ | |||
+ | Por ter um prefixo mais longo, o tamanho dessa subrede é menor. Isso significa que ela contém menos endereços IP, tanto que o primeiro endereço é ''192.168.2.0'' e o último é ''192.168.2.15''. Essa subrede poderia ser representada por: | ||
+ | * '''192.168.2.0/255.255.255.240''' | ||
+ | * '''192.168.2.0/28''' | ||
+ | |||
+ | |||
+ | Aproveitando esse exemplo, pode-se mostrar uma outra subrede que, apesar de não parecer, é diferente da anterior: | ||
+ | |||
+ | |||
+ | [[imagem:Pji-prefixo3.png|400px]] | ||
+ | |||
+ | |||
+ | Essa outra subrede contém endereços entre ''192.168.2.16'' e ''192.168.2.31''. Essa subrede poderia ser representada por: | ||
+ | * '''192.168.2.16/255.255.255.240''' | ||
+ | * '''192.168.2.16/28''' | ||
+ | |||
+ | == O que todo host deve possuir == | ||
+ | |||
+ | Com o que se fez até o momento, pode-se concluir que todo host (computador, tablet, smartphone, ..., qualquer dispositivo que rode aplicações da Internet) precisa de: | ||
+ | * '''Endereço IP e máscara de rede''': um host precisa de um endereço para que possa se comunicar com outros hosts. A máscara de rede informa o tamanho da subrede IP em que ele se encontra. | ||
+ | * '''Rota default (padrão)''': para se comunicar com hosts de outras subredes, é preciso enviar os pacotes para um roteador que saiba encaminhá-los a seus destinos. O roteador ''default'' (ou ''padrão'') é um roteador para quem se destinam todos esses pacotes. Tecnicamente ele corresponde à rota para o destino ''0.0.0.0/0''. | ||
+ | * '''Endereço IP do servidor DNS''': usuários costumam endereçar hosts e servidores por seus nomes de domínio, e não por seus endereços IP. Isso é muito mais fácil de memorizar do que os endereços numéricos. Como explicado em aula, nomes de domínio são análogos a nomes de assinantes em um catálogo telefônico. No entanto, as aplicações precisam dos endereços IP para se comunicarem. O servidor DNS faz a tradução de nome de domínio para endereço IP, e é usado pelas aplicações transparentemente (isso é, você não percebe que isso ocorre). O endereço desse servidor deve ser configurado em cada host, para que se possam traduzir nomes de domínio. | ||
+ | |||
+ | === Exercícios === | ||
+ | |||
+ | Resolva estes exercícios sobre subredes, prefixos e máscaras. | ||
+ | |||
+ | # O tamanho de uma subrede é definido pela quantidade de endereços IP que ela contém. Quais os tamanhos de cada subrede mostrada nos exemplos da seção anterior ? | ||
+ | # Sejam as subredes A: ''192.168.2.48/28'', B: ''192.168.2.64/26'', C: ''192.168.2.192/27'', D: ''192.168.2.128/29'' e E: ''192.168.2.0/27''. Informe em qual dessas subredes se encontram estes endereços IP: | ||
+ | #* 192.168.2.126 | ||
+ | #* 192.168.2.25 | ||
+ | #* 192.168.2.62 | ||
+ | #* 192.168.2.200 | ||
+ | #* 192.168.2.100 | ||
+ | #* 192.168.2.80 | ||
+ | # Informe qual o tamanho de cada uma das subredes do exercício anterior. | ||
+ | # Informe quais o primeiro e último endereços IP de cada uma daquelas subredes. | ||
+ | # A subrede 192.168.2.0/24 foi subdividida em subredes de tamanho 32. Liste todas as subredes que são possíveis definir com essas características (informe prefixo e máscara). | ||
+ | # A subrede 192.168.2.0/24 foi subdividida em subredes com máscara 26. Liste todas as subredes que são possíveis definir com essas características (prefixo e máscara), informando também seus tamanhos. | ||
+ | # Uma subrede do câmpus é 172.18.128.0/18. Calcule seu tamanho, seu endereço inicial e final. | ||
+ | # Calcule o tamanho, endereço inicial e final da rede sem-fio do IFSC. | ||
+ | # Use este [http://tele.sj.ifsc.edu.br/~msobral/IER/ipkit/ simulador (IPKit)] para criar as seguintes redes e definir as rotas que nelas devem existir: | ||
+ | #* '''OBS:''' antes de usar esse simulador execute este comando em um terminal:<syntaxhighlight lang=bash> | ||
+ | sudo apt install icedtea-7-plugin | ||
+ | </syntaxhighlight>... e depois reinicie o Firefox. | ||
+ | |||
+ | |||
+ | {| border=1 | ||
+ | |- | ||
+ | | [[imagem:PJI2-rotas-Rede1.jpg|300px]]<br>''Rede 1'' | ||
+ | |- | ||
+ | |[[imagem:PJI2-rotas-Rede2.jpg|400px]]<br>''Rede 2'' | ||
+ | |- | ||
+ | |[[imagem:PJI2-rotas-Rede3.jpg|400px]]<br>''Rede 3'' | ||
+ | |- | ||
+ | |[[imagem:PJI2-rotas-Rede4.jpg|400px]]<br>''Rede 4'' | ||
+ | |} | ||
+ | |||
+ | |||
+ | Esse exercício pode também ser realizado com um emulador de rede chamado Netkit2. | ||
+ | |||
+ | </font> | ||
+ | {{Collapse bottom | Aula 24}} | ||
+ | |||
+ | =10/05/2018: Netkit2= | ||
+ | |||
+ | {{Collapse top | Aula 25}} | ||
+ | <font size="3"> | ||
+ | |||
+ | == AVISO: ATUALIZAÇÃO MANUAL PARA VERSÃO 2.x == | ||
+ | |||
+ | O netkit2 possui um bug que o impede se atualizar. Para corrigi-lo, deve-se atualizá-lo manualmente com este procedimento: | ||
+ | # Abrir um terminal | ||
+ | # Baixar o programa do ''Netkit2'' com este comando: <syntaxhighlight lang=bash> | ||
+ | wget http://tele.sj.ifsc.edu.br/~msobral/netkit2/bin/netkit2 | ||
+ | </syntaxhighlight> | ||
+ | # Copiá-lo para o diretório do Netkit2: <syntaxhighlight lang=bash> | ||
+ | cp netkit2 ${NETKIT2_HOME}/bin/ | ||
+ | </syntaxhighlight> | ||
+ | # Executar o ''netkit2'' para completar a atualização | ||
+ | |||
+ | == Introdução == | ||
+ | |||
+ | Netkit2 é um ambiente para experimentos com redes de computadores desenvolvido pela Área de Telecomunicações do IFSC (Câmpus São José), e que se inspirou no [http://www.netkit.org Netkit], uma ferramenta semelhante (mas mais simplificada) desenvolvida pela Universidade de Roma, na Itália. Com ele torna-se possível realizar experimentos sobre configuração básica de rede, roteamento, criação de infraestrutura WAN com MPLS, além de dispor de diversos serviços de rede (DNS, WWW, LDAP, e outros). Ele se compõe de máquinas virtuais Linux (implementadas com [http://user-mode-linux.sourceforge.net/ kernel Linux UML – User Mode Linux]), que funcionam como roteadores ou computadores, e hubs Ethernet virtuais (UML switch) para interligar as máquinas virtuais. Para todos os efeitos, cada máquina virtual funciona como se fosse um computador real, possuindo uma ou mais interfaces de rede. Com esses recursos é possível criar redes de configurações arbitrárias para estudar protocolos de comunicação e serviços de rede. | ||
+ | |||
+ | |||
+ | O Netkit aqui descrito possui muitas diferenças em relação ao [http://www.netkit.org Netkit original], dentre elas: | ||
+ | * A definição de tipos de equipamentos a serem usados no experimento, tais como roteadores, switches, e computadores de uso geral: cada máquina virtual pode assim ser especializada para facilitar sua configuração. | ||
+ | * A possibilidade de definir diversos parâmetros de configuração de rede (ex: endereços de interfaces, rotas, VLANs, ...) diretamente no arquivo de configuração de um experimento. | ||
+ | * A possibilidade de criar enlaces ponto-a-ponto via links seriais virtuais, que podem ter configurados suas taxas de bits, taxas de erro (BER) e atraso de propagação. | ||
+ | * Uma interface gráfica para a execução de experimentos. Esse aplicativo concentra as telas de terminal das máquinas virtuais e provê diversas funções auxiliares para ajudar na realização dos experimentos. A figura abaixo mostra um exemplo dessa interface em ação: | ||
+ | |||
+ | [[imagem:Netkit-vlsm1.png|centro|640px]] | ||
+ | |||
+ | |||
+ | A segunda versão do Netkit apresentada neste artigo, chamada daqui em diante de Netkit2, é fruto de uma ampla reescrita da [[Netkit|versão anterior]]. As principais modificações nesta segunda versão são: | ||
+ | * '''Completa reescrita do interpretador do arquivo de configuração de experimento''': o novo interpretador analisa mais criteriosamente a sintaxe da configuração de um experimento, e informa detalhadamente erros de sintaxe encontrados. Além disso, algumas modificações na sintaxe de configurações foram realizadas para torná-las mais consistentes. | ||
+ | * '''Completa reescrita do software que inicia e controla as máquinas virtuais UML''': na versão anterior isso ainda era realizado com os scripts do Netkit original, os quais possuíam limitações (ex: apenas uma interface ''tap'' por experimento, impossibilidade de execução de mais de um experimento no mesmo computador, entre outras). | ||
+ | * '''Uso de um novo kernel e sistema de arquivos''': na versão anterior usava-se o kernel 2.6.27 e sistema de arquivos Debian 6 do Netkit original. Agora usa-se um kernel 3.9 e sistema de arquivos Ubuntu 12.04. | ||
+ | * '''Desenvolvimento de uma interface clara entre a execução de experimentos e sua visualização''': apesar de aparentemente a nova versão ter a mesma interface de usuário da versão anterior, houve uma separação clara entre execução e visualização. Com isso, pode-se usar a [[Netkit2#API_do_Netkit|API desenvolvida]] para criar facilmente novas interfaces de usuário. | ||
+ | |||
+ | |||
+ | As próximas seções explicam como instalar o Netkit, e como criar e executar experimentos. | ||
+ | |||
+ | == Sistemas Operacionais compatíveis == | ||
+ | |||
+ | {| border="1" cellpadding="5" cellspacing="0" style="text-align: center;" | ||
+ | |- | ||
+ | ! style="background: #efefef;" | Sistema operacional | ||
+ | ! style="background: #efefef;" | Compatível | ||
+ | ! style="background: #efefef;" | Incompatível | ||
+ | |- | ||
+ | | Debian 6 Squeeze | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Debian 7 Wheezy | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Ios MAC | ||
+ | | | ||
+ | | X | ||
+ | |- | ||
+ | <!-- Começo de comentário | ||
+ | | Ubuntu 10.04 Lucid Lynx LTS | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Ubuntu 10.10 Maverick Meerkat | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Ubuntu 11.04 Natty Narwhal | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Ubuntu 11.10 Oneiric Ocelot | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Ubuntu 12.04 Precise Pangolin LTS | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Ubuntu 12.10 Quantal Quetzal | ||
+ | | X -> marque aqui se o sistema for compatível | ||
+ | | X -> marque aqui se o sistema não for compatível | ||
+ | |- | ||
+ | | Ubuntu 13.04 Raring Ringtail | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Ubuntu 13.10 Saucy Salamander | ||
+ | | X -> marque aqui se o sistema for compatível | ||
+ | | X -> marque aqui se o sistema não for compatível | ||
+ | |- | ||
+ | Final do comentário --> | ||
+ | | Versões do Ubuntu inferiores a 13.10 | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Ubuntu 14.04 Trusty Tahr LTS | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | <!-- Começo de comentário | ||
+ | | Ubuntu 14.10 Utopic Unicorn | ||
+ | | X -> marque aqui se o sistema for compatível | ||
+ | | X -> marque aqui se o sistema não for compatível | ||
+ | |- | ||
+ | Final do comentário --> | ||
+ | | Ubuntu 15.04 Vivid Vervet | ||
+ | | X | ||
+ | | | ||
+ | |- | ||
+ | | Windows, qualquer versão | ||
+ | | | ||
+ | | X | ||
+ | |- | ||
+ | |- | ||
+ | {| border="0" | ||
+ | |} | ||
+ | |||
+ | OBS: A versão utilizada nos laboratórios é o Ubuntu 12.04 LTS | ||
+ | |||
+ | == Instalação == | ||
+ | |||
+ | A instalação pode ser feita de forma automática ou manual. Em ambos os casos, é necessário haver 1,5 GB livre em seu disco. | ||
+ | |||
+ | O Netkit foi criado para rodar em sistemas operacionais de 32 bits. Mas ele pode ser usado também em sistemas de 64 bits. Nesse caso, devem-se instalar os seguintes pacotes de software (instale-os com '''apt-get'''): | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | sudo apt-get install libc6-i386 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Tanto para sistemas de 32 ou 64 bits, são necessários os seguintes pacotes de software para o correto funcionamento do Netkit: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | sudo apt-get install graphviz python-vte bridge-utils uml-utilities | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Após instalado, o Netkit pode ser atualizado executando-se '''netkit2''' e usando o menu ''General->Update''. | ||
+ | |||
+ | === Instalação automática (recomendada) === | ||
+ | |||
+ | '''OBS:''' o instalador assume que a instalação será feita em um sistema operacional [http://www.ubuntulinux.org/ Ubuntu 10.04] ou superior, <br>e que o usuário use o shell [http://www.gnu.org/s/bash/ Bash] (''/bin/bash''). | ||
+ | |||
+ | |||
+ | Obtenha o [http://tele.sj.ifsc.edu.br/~msobral/netkit2/netkit2-installer instalador do Netkit] e salve-o no disco de seu computador. Execute-o da seguinte forma em uma janela de terminal: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | python netkit2-installer | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | O instalador será iniciado e apresentará a seguinte tela: | ||
+ | |||
+ | [[imagem:Netkit-installer.png]] | ||
+ | |||
+ | Normalmente deve-se usar a opção ''Install from Network'', que faz o download do [http://tele.sj.ifsc.edu.br/~msobral/netkit2/install/netkit2.tar.bz2 arquivo de instalação] e o instala. Note que esse arquivo de instalação possui pouco mais de 270 MB, e pode demorar para ser copiado pela rede. A opção ''Install from File'' pode ser usada se o arquivo de instalação já estiver em seu disco. | ||
+ | |||
+ | |||
+ | O instalador realiza automaticamente os procedimentos descritos na seção [[Netkit#Instala.C3.A7.C3.A3o_manual|Instalação manual]]. | ||
+ | |||
+ | === Instalação manual === | ||
+ | |||
+ | Para instalar o Netkit, deve-se obter o arquivo compactado '''netkit2.tar.bz2''' (330 MB): | ||
+ | * [http://tele.sj.ifsc.edu.br/~msobral/netkit2/install/netkit2.tar.bz2 Cópia no servidor de Tele (atualizada em 01/08/2014)] | ||
+ | * … ou traga um pendrive com 500 MB livres, um CD-R ou um DVD-R | ||
+ | |||
+ | |||
+ | O Netkit foi completamente modificado em relação à [http://www.netkit.org distribuição original do projeto] para possibilitar uma sintaxe mais rica para a configuração de experimentos. A nova sintaxe é orientada a componentes de rede, tais como computadores, gateways, switches e roteadores, gerando máquinas virtuais previamente configuradas de acordo com seu papel na rede. Outra melhoria foi a possibilidade de criar enlaces ponto-a-ponto entre máquinas virtuais usando interfaces seriais. Esses enlaces emulam a comunicação via portas seriais, e neles é possível usar um protocolo de enlace ponto-a-ponto (ex: [http://www.faqs.org/rfcs/rfc1661.html PPP]). | ||
+ | |||
+ | Você precisa de um computador com Linux, para onde deve copiar os arquivos acima. Não é necessário ter privilégio de superusuário para instalar o Netkit, tampouco para executá-lo. Aliás, NÃO EXECUTE O NETKIT COMO SUPERUSUÁRIO !!! | ||
+ | |||
+ | Após copiar o arquivo [http://tele.sj.ifsc.edu.br/~msobral/netkit2/install/netkit2.tar.bz2 netkit2.tar.bz2] para seu computador, descompacte-o dentro de um subdiretório à sua escolha. Em seguida edite o arquivo ~/.profile (que contém a configuração do seu shell), e acrescente as seguintes definições de variáveis de ambiente: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | export NETKIT2_HOME=/home/aluno/netkit2 | ||
+ | export PATH=$NETKIT2_HOME/bin:$PATH | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Obs: no exemplo acima foi assumido que o Netkit foi instalado em ''/home/aluno/netkit2'' (quer dizer, você descompactou os arquivos dentro de ''/home/aluno/netkit2''). Caso tenha instalado em outro diretório você deve corrigir a definição da variável de ambiente NETKIT2_HOME. | ||
+ | |||
+ | === Ajustes finais === | ||
+ | |||
+ | Alguns ajustes precisam ser feitos manualmente. Em particular, deve-se editar o arquivo [http://manpages.ubuntu.com/manpages/precise/man5/sudoers.5.html sudoers] para que o '''netkit2''' tenha permissão de executar alguns comandos. Use o programa [http://manpages.ubuntu.com/manpages/precise/man8/visudo.8.html visudo] para adicionar o comando ''${NETKIT2_HOME}/bin/tap.py'' ao ''sudoers'' (substitua ''${NETKIT2_HOME}'' pelo diretório onde o Netkit2 foi instalado). Por exemplo, se ${NETKIT2_HOME} for ''/home/aluno/netkit2'', use o programa '''visudo''' para adicionar a seguinte linha (pode ser ao final da tela): | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | aluno ALL=(root) NOPASSWD: SETENV: /home/aluno/netkit2/bin/tap.py | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | |||
+ | '''OBS:''' No Ubuntu 14.04 LTS, recomenda-se desabilitar o menu global da interface Unity. Nesse caso, use o aplicativo [http://manpages.ubuntu.com/manpages/trusty/man1/dconf-editor.1.html dconf-editor] para adicionar ''netkit2'' a ''com -> canonical -> unity-gtk-module -> blacklist'' ([http://www.webupd8.org/2013/11/unity-global-menu-can-now-be-disabled.html maiores detalhes]). A tela do dconf-editor após a modificação está exemplificada a seguir. | ||
+ | |||
+ | |||
+ | [[imagem:Dconf-nk2.png]] | ||
+ | |||
+ | === Testando a instalação === | ||
+ | |||
+ | Para estrear seu Netkit você pode baixar o arquivo [http://tele.sj.ifsc.edu.br/~msobral/netkit2/teste.conf teste.conf], que descreve um experimento. Para rodá-lo siga estes passos: | ||
+ | # Execute ''. ~/.profile'' . Isto será necessário somente desta vez, pois das próximas vezes que iniciar o computador as configurações de ambiente do Netkit2 serão automaticamente carregadas. | ||
+ | # Execute '''netkit2'''. Deve aparecer a tela abaixo:<br><br>[[imagem:Screenshot-gnome-netkit.png]]<br><br> | ||
+ | # Na tela do '''netkit2''' clique em ''File->Load and Run''. Em seguida escolha o arquivo de configuração de experimento ''teste.conf''. | ||
+ | # Após selecionar o arquivo de configuração, o experimento é automaticamente iniciado. A tela do '''netkit2''' mostra o terminal (contendo um ''shell'') de uma das máquinas virtuais. Para selecionar outra máquina virtual basta clicar no botão corresponde (logo abaixo da tela do terminal, como se pode ver abaixo). <br><br>[[imagem:netkit2-1.png]]<br><br> | ||
+ | # Clique em ''File->Graph'' para visualizar um diagrama da topologia da rede em execução.<br><br>[[imagem:netkit2-2.png]]<br><br> | ||
+ | |||
+ | O experimento de exemplo contém a seguinte rede: | ||
+ | |||
+ | [[imagem:netkit2-lab1.png]] | ||
+ | |||
+ | Experimente a comunicação entre os computadores dessa rede, usando o comando ''ping''. Investigue também que interfaces de rede existem em cada um deles, usando o comando ''ifconfig''. Veja que rotas estáticas foram definidas usando o comando ''netstat -rn''. Finalmente, para visualizar o tráfego experimente selecionar o ítem de menu ''Wireshark->any'' e em seguida fazer ''ping'' entre os computadores. | ||
+ | |||
+ | === O menu do netkit2 === | ||
+ | |||
+ | Os ítens de menu do '''netkit2''' tem as seguintes funções: | ||
+ | |||
+ | '''Menu ''File'':''' | ||
+ | * '''Load Only''': carrega um arquivo de configuração de experimento, mas não o executa. Se um experimento já tiver sido carregado e estiver em execução, primeiro ele será terminado. | ||
+ | ** '''Drag and Drop (arrastar e soltar)''': pode-se carregar um experimento usando a função de arrastar e soltar. Pode-se arrastar um link para uma URL (ex: a partir de um navegador web), ou um arquivo da área de trabalho ou gerenciador de arquivos. Isso funciona somente se nenhum experimento estiver em execução. | ||
+ | * '''Load and Run''': carrega um arquivo de configuração de experimento e o executa imediatamente. Se um experimento já tiver sido carregado e estiver em execução, primeiro ele será terminado. | ||
+ | * '''Export''': exporta um projeto do Netkit, o qual contém o arquivo de configuração (extensão .conf) e arquivos preservados das máquinas virtuais. Ver maiores detalhes na seção sobre [[Netkit#Projetos|Projetos do Netkit]]. | ||
+ | * '''Import from folder''': importa um projeto do Netkit contido em um subdiretório. Ver maiores detalhes na seção sobre [[Netkit#Projetos|Projetos do Netkit]]. | ||
+ | * '''Import from file''': importa um projeto do Netkit contido em um arquivo compactado. Ver maiores detalhes na seção sobre [[Netkit#Projetos|Projetos do Netkit]]. | ||
+ | * '''Edit''': abre o editor de texto [http://projects.gnome.org/gedit/ gedit] para poder editar a configuração do experimento. | ||
+ | * '''Graph''': mostra/esconde um diagrama da topologia da rede | ||
+ | * '''Clear''': para o experimento e mostra a tela inicial do '''netkit2''' | ||
+ | * '''Quit''': termina o experimento e encerra o '''netkit2'''. | ||
+ | |||
+ | |||
+ | '''Menu ''Network'':''' | ||
+ | * '''Start''' ou '''Restart''': | ||
+ | ** '''Start''': inicia um experimento cujo arquivo de configuração foi carregado mais ainda não executado (i.e. usando ''File->Load Only''). Se o arquivo de configuração tiver sido modificado desde o instante em que foi carregado, será novamente lido antes de ser executado. | ||
+ | ** '''Restart''': reinicia um experimento que já esteja em execução, recarregando seu arquivo de configuração caso tenha sido modificado. | ||
+ | * '''Stop''': termina um experimento, parando todas suas máquinas virtuais. | ||
+ | * '''Reload''': recarrega o arquivo de configuração do experimento corrente, caso tenha sido modificado. Se o experimento estiver em execução, termina-o primeiro. | ||
+ | |||
+ | '''Menu ''Wireshark'':''' | ||
+ | * Cada ítem deste menu mostra o nome de uma interface de rede da máquina virtual selecionada. O ítem '''''any''''' representa todas as interfaces de rede. Ao selecionar um desses ítens, um processo de captura de pacotes é acionado na máquina virtual selecionada. Em seguida é executado o [http://www.wireshark.org Wireshark] para visualizar o tráfego coletado. | ||
+ | |||
+ | |||
+ | '''Menu ''General'':''' | ||
+ | * '''Help''': abre uma página de ajuda do Netkit. | ||
+ | * '''About''': mostra uma tela com informações gerais sobre o '''netkit2'''. | ||
+ | * '''Update''': atualiza para a nova versão do '''netkit2'''. | ||
+ | * '''Package Install Mode''': ativa o [[Netkit#Modo_de_instala.C3.A7.C3.A3o_de_software|modo de instalação de software]], em que uma única máquina virtual é executada e com acesso em modo leitura-escrita ao sistema de arquivos. Softwares e modificações feitas em arquivos nesse modo de execução serão permanentes. | ||
+ | * '''Restart netkit2''': reinicia o '''netkit2''' (neccessário após a atualização de versão). | ||
+ | * '''Preferences''': possibilita modificar algumas opções de execução de experimentos, tais como diretório de trabalho (''default: diretório atual''), quantidade de máquinas virtuais que podem ser iniciadas simultaneamente, e quantidade de memória alocada a cada máquina virtual. | ||
+ | |||
+ | |||
+ | A próxima seção descreve em detalhes como configurar um experimento do Netkit. | ||
+ | |||
+ | === Softwares disponíveis nas máquinas virtuais === | ||
+ | |||
+ | A imagem do sistema operacional das máquinas virtuais se baseia no Ubuntu 12.04. Nele foram instalados diversos softwares para a realização de experimentos de rede. | ||
+ | |||
+ | |||
+ | {{collapse top | Lista de softwares de rede instalados }} | ||
+ | {| border=1 | ||
+ | !Pacote de software | ||
+ | !Descrição | ||
+ | |- | ||
+ | |[http://httpd.apache.org/ apache2] + [http://php.net/ php5] || servidor web Apache + PHP5 | ||
+ | |- | ||
+ | |[http://manpages.ubuntu.com/manpages/precise/man8/iptables.8.html iptables] / [http://manpages.ubuntu.com/manpages/precise/man8/ebtables.8.html ebtables] || filtro de pacotes IPv4 / filtro de quadros ethernet | ||
+ | |- | ||
+ | | [http://www.asterisk.org/community/documentation asterisk] || um PBX por software | ||
+ | |- | ||
+ | | [https://help.ubuntu.com/community/BIND9ServerHowto bind9] || servidor DNS | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/en/man1/bmon.1.html bmon] || monitor de uso de banda e estimador de taxa de bits | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/bwm-ng.1.html bwm-ng] || outro monitor de uso de banda e estimador de taxa de bits | ||
+ | |- | ||
+ | |[http://www.cacti.net/ cacti] / [http://manpages.ubuntu.com/manpages/precise/man1/spine.1.html cacti-spine]|| gerador de gráficos de utilização de recursos do sistema e da rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/cbm.1.html cbm] || mostra o tráfego atual em todas as interfaces de rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/clamd.8.html clamav] || um antivirus útil para uso com MTA | ||
+ | |- | ||
+ | | [http://www.linux-ha.org/wiki/Cluster_Glue cluster-glue] || ferramentas para criação de clusters (parte do projeto Linux-HA) | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/curl.1.html curl] || utilitário para transferir URL | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/dhcpd.8.html dhcp3-server] || servidor DHCP | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/dig.1.html dig] || utilitário para consultas DNS | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/dovecot.8.html dovecot] || servidor IMAP e POP3 | ||
+ | |- | ||
+ | |[http://www.drbd.org/ drbd] || espelhamento de discos através de uma rede (usado em clusters) | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/ejabberd.8.html ejabberd] || servidor Jabber / XMPP | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/freeradius.8.html freeradius] || servidor Radius | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/gpg.1.html gpg] || ferramenta para encriptação e assinatura digital | ||
+ | |- | ||
+ | | [http://www.linux-ha.org/wiki/Heartbeat heartbeat] || monitor de recursos para clusters (parte do projeto Linux-HA) | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/hping3.8.html hping3] || ferramenta que envia pacotes TCP/IP (quase) arbitrários para hosts | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/htop.1.html htop] || visualizador de processos interativo | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/ifstat.1.html ifstat] || mostra estatísticas de interfaces de rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/iftop.8.html iftop] || mostra o uso de banda em interfaces de rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/iperf.1.html iperf] || realiza testes de vazão da rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/setkey.8.html ipsec-tools] || utilitários para manipular parâmetros IPSec | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/utopic/en/man8/ip-route.8.html iproute] || utilitário para manipular a tabela de rotas | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/iptraf.8.html iptraf] || monitor de tráfego em interfaces de rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/lynx.1.html lynx] || um navegador web em modo texto | ||
+ | |- | ||
+ | | [http://www.list.org/ mailman] || um gerenciador de listas de email | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/monkey.8.html monkey] || um servidor web minimalista | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/mtr.8.html mtr] || ferramenta para diagnóstico de rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/mysqld.8.html mysql] || servidor Mysql e utilitários | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/nagios3.8.html nagios] || monitor de sistema e rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/ncftp3.1.html ncftp] || um cliente FTP | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/ndisc6.8.html ndisc6] || utilitário que implementa ICMPv6 Neighbor Discovery | ||
+ | |- | ||
+ | | [http://packages.ubuntu.com/precise/netdiag netdiag] || conjunto de utilitários para monitoramento de rede (trafshow,strobe,netwatch,statnet,tcpspray,tcpblast) | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/nethogs.8.html nethogs] || mostra o uso da banda por processo | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/netperf.1.html netperf] || um benchmark para desempenho de rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/ngrep.8.html ngrep] || um ''grep'' de rede - captura pacotes de acordo com expressões regulares | ||
+ | |- | ||
+ | | [http://linux.die.net/man/1/nload nload] || mostra o uso da rede atual | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/en/man1/nmap.1.html nmap] || ferramenta para exploração da rede e varredura de portas | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/ntop.8.html ntop] || mostra o uso da rede via web | ||
+ | |- | ||
+ | | [https://help.ubuntu.com/lts/serverguide/openldap-server.html openldap] || servidor OpenLDAP | ||
+ | |- | ||
+ | |[http://sourceforge.net/projects/opennhrp opennhrp] || um daemon para implantar DMVPN | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/pktstat.1.html pktstat] || mostra a taxa de bits de diferentes tipos de pacotes por uma interface | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/ssh.1.html openssh] || cliente e servidor SSH | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/openvpn.8.html openvpn] || cria VPNs baseadas em OpenSSL | ||
+ | |- | ||
+ | | [http://www.pjsip.org/ pjsip] || ferramenta para testes de comunicação multimedia (audio e video com SIP, RTP e outros protocolos) | ||
+ | |- | ||
+ | | [https://help.ubuntu.com/community/Postfix postfix] || MTA Postfix | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/utopic/en/man8/proftpd.8.html proftpd] || servidor FTP | ||
+ | |- | ||
+ | | [http://www.nongnu.org/quagga/ quagga] || conjunto de protocolos de roteamento | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/racoon.8.html racoon] || daemon para gerenciar chaves IKE, usado em IPSec | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/radvd.8.html radvd] || daemon para divulgação de roteador em redes IPv6 | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/rdnssd.8.html rdnssd] || daemon para descoberta de servidor DNS em redes IPv6 | ||
+ | |- | ||
+ | | [http://www.linux-ha.org/wiki/Resource_Agents resource-agents] || interface para recursos em clusters (parte do projeto Linux-HA) | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/rsync.1.html rsync] || ferramenta para cópia de arquivos através da rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man7/samba.7.html samba] || servidor de arquivos e impressoras com protocolos da rede Windows | ||
+ | |- | ||
+ | |[http://manpages.ubuntu.com/manpages/precise/man8/shorewall.8.html shorewall] / [http://manpages.ubuntu.com/manpages/precise/man8/shorewall6.8.html shorewall6] || firewall para IPv4 / IPv6 | ||
+ | |- | ||
+ | | [http://sipp.sourceforge.net/ sipp] || ferramenta para gerar tráfego de testes para SIP | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/snmpd.8.html snmpd] || agente SNMP e ferramentas correlatas | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/speedometer.1.html speedometer] || mede e mostra a taxa de bits em uma interface | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/squid3.8.html squid] || servidor proxy e cache para web | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/en/man8/stunnel4.8.html stunnel] || cria túneis SSL | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/lucid/man1/svn.1.html subversion] || sistema de controle de versão para desenvolvimento colaborativo | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/tc.8.html tc] || utilitário para manipular o ''traffic shaper'' | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/tcpd.8.html tcpd] || TCP-wrappers: controle de acesso a serviços de rede baseados em TCP | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/tcpdump.8.html tcpdump] || captura e análise de tráfego na rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/tcptrack.1.html tcptrack] || monitora conexões TCP | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/tshark.1.html tshark] || captura e análise de tráfego na rede | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/vsftpd.8.html vsftpd] || servidor FTP com ênfase em segurança | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man1/webalizer.1.html webalizer] || analisador de logs de servidores web e proxy | ||
+ | |- | ||
+ | | [http://manpages.ubuntu.com/manpages/precise/man8/wu-ftpd.8.html wu-ftpd] || servidor FTP clássico | ||
+ | |- | ||
+ | |[http://manpages.ubuntu.com/manpages/precise/man8/xl2tpd.8.html xl2tpd] || um cliente/daemon para L2TP | ||
+ | |} | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | == Criação de experimentos == | ||
+ | |||
+ | <!-- Obs: lembre destes comandos: | ||
+ | * '''labstart''': executa um experimento | ||
+ | * '''labhalt''': termina um experimento (mata as máquinas virtuais) --> | ||
+ | |||
+ | Para criar um experimento do Netkit, deve-se escrever um arquivo de configuração com extensão ''.conf'' (sugestão: Lab.conf). Esse arquivo deve conter a configuração da rede do seu experimento. Nele devem-se identificar os atributos globais do experimento, as máquinas virtuais que compõem a rede, seus tipos e como se conectam suas interfaces de rede. O tipo de máquina virtual diz respeito ao seu papel na rede, que pode ser: | ||
+ | |||
+ | * [[Netkit2#M.C3.A1quinas_gen.C3.A9ricas_.28computadores_simples.29|generic:]] uma máquina virtual comum, e que pode representar um computador sem nada de especial. | ||
+ | * [[Netkit2#Gateways_.28computadores_que_interligam_subredes.29|gateway:]] possui as capacidades de ''generic'', e adiciona a função de ''gateway''. Isto é, esse tipo de máquina virtual encaminha datagramas IP entre suas interfaces de rede. | ||
+ | * [[Netkit2#M.C3.A1quinas_com_suporte_a_PPPoE|pppoe:]] especializa ''gateway'' para adicionar a capacidade de estabelecer enlaces [[IER-2011-1#PPPoE_.28PPP_over_Ethernet.29|PPPoE]] (i.e. criar um AC PPPoE). | ||
+ | * [[Netkit2#Switches_MPLS|mpls:]] estende o tipo ''pppoe'', possibilitando criar um switch MPLS rudimentar. Com ele se podem criar LSP (circuitos-virtuais) estáticos e túneis. | ||
+ | * [[Netkit2#Roteadores|router:]] estende o tipo ''mpls'' de forma a operar como um roteador. Usa o programa [http://www.quagga.net/ Quagga] que implementa os protocolos de roteamento RIP, OSPF e BGP. Apresenta uma interface semelhante ao terminal de um roteador Cisco. | ||
+ | * [[Netkit2#Switches|switch:]] estende o tipo ''generic'' para criar um switch Ethernet com suporte a VLANs IEEE 802.1q, enlaces agregados IEEE 802.1ax, protocolo STP segundo a norma IEEE 802.1d e controle de acesso IEEE 802.1x. | ||
+ | * [[Netkit2#PBX_IP_.28Asterisk.29|pbx:]] estende o tipo ''gateway'' para criar um PBX IP baseado em Asterisk. | ||
+ | |||
+ | |||
+ | O diagrama abaixo mostra a hierarquia dos tipos de componentes de rede por ora definidos: | ||
+ | |||
+ | [[imagem:Netkit2-tipos.png]] | ||
+ | |||
+ | === Máquinas genéricas (computadores simples) === | ||
+ | |||
+ | Máquinas genéricas são computadores que possuem uma ou mais interfaces de rede. No Netkit eles foram definidos para representar computadores de usuários ou servidores. | ||
+ | |||
+ | No exemplo abaixo duas máquinas genéricas, ''pc1'' e ''pc2'', têm suas interfaces ethernet ''eth0'' conectadas à mesma rede local. | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # Primeiro devem-se definir os tipos de maquinas virtuais do experimento. | ||
+ | # Um computador Linux genérico é do tipo "generic": | ||
+ | # nome_vm[type]=generic | ||
+ | |||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | |||
+ | # Em seguida podem-se definir as interfaces de rede Ethernet: | ||
+ | # nome_vm[nome_interface]=nome_rede_local:ip=IP/MASCARA | ||
+ | |||
+ | pc1[eth0]=lan0:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=lan0:ip=192.168.0.2/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A rede resultante é: | ||
+ | |||
+ | [[imagem:netkit-lab1.png]] | ||
+ | |||
+ | Para ver esse experimento em ação, copie o conteúdo acima para um arquivo (ex: Lab.conf). Em seguida execute o '''netkit2''' e clique o botão ''Load'' para carregar esse arquivo de configuração. Assim que tiver concluído o início do experimento, você deve poder acessar as máquinas virtuais ''pc1'' e ''pc2''. Ambas possuem suas interfaces de rede ''eth0'' configuradas com os endereços IP informados em ''Lab.conf''. A figura abaixo mostra a tela do '''netkit2''' com as máquinas virtuais: | ||
+ | |||
+ | [[imagem:Screenshot-gnome-netkit-4.png|800px]] | ||
+ | |||
+ | Quando uma máquina virtual é iniciada, suas interfaces de rede precisam ser configuradas. Além disso, outros comandos podem ser necessários para prepará-la para o experimento, tais como criação de rotas estáticas ou inicialização de serviços de rede. Esses comandos adicionais podem ser adicionados ao arquivo ''nome_vm.startup'' (ex: para a máquina virtual ''pc1'' o arquivo deve se chamar ''pc1.startup''). No entanto, algumas opções de configuração mais comuns (como endereços IP de interfaces) podem ser feitas diretamente no arquivo de configuração ''Lab.conf''. Assim, o próprio ''netkit2'' configura automaticamente as máquinas virtuais quando inicia um experimento. Se houver necessidade de editar manualmente os arquivos ''nome_vm.startup'', adicione seus comandos depois da linha: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | /hostlab/nome_vm-auto.sh | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ==== Interligando interfaces de rede ==== | ||
+ | |||
+ | No exemplo anterior, os dois computadores tiveram suas interfaces de rede interligadas. No Netkit o link entre interfaces é especificado por um ''nome_ de_link'', que pode ser uma palavra qualquer a seu critério. Destacando a interligação das interfaces do exemplo anterior, nota-se que o nome do link é ''lan0'': | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[eth0]=lan0:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=lan0:ip=192.168.0.2/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Assim, todas as interfaces que estiverem associadas ao mesmo nome de link pertencerão ao mesmo enlace. Inclusive é possível conectar mais de duas interfaces ethernet, que assim se comunicarão como se houvesse um ''hub'' a interligá-las. | ||
+ | |||
+ | Observe que ''nome_de_link'' pode ser qualquer coisa. O Netkit não o interpreta nem o associa a qualquer nome de máquina virtual. Ele serve somente para informar as interfaces de rede que devem estar interligadas. | ||
+ | |||
+ | Interfaces podem ser declaradas para iniciarem desativadas. Para obter esse efeito, basta acrescentar o atributo ''down'' à interface, como neste exemplo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[eth0]=lan0:ip=192.168.0.1/24 | ||
+ | |||
+ | # interface eth0 de pc2 inicia desativada | ||
+ | pc2[eth0]=lan0:ip=192.168.0.2/24:down | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ===== Usando DHCP ===== | ||
+ | |||
+ | Interfaces de rede do tipo ethernet também podem ser configuradas usando [[GER-2010-1#DHCP|DHCP]]. Para isso, deve-se definir o parâmetro IP da interface de rede da seguinte forma: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc[eth0]=link:ip=dhcp | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Para que o DHCP funcione, deve existir ao menos um servidor DHCP dentro do mesmo domínio de broadcast ethernet. Isso se faz definindo o atributo ''dhcp'' de uma máquina virtual, como mostrado abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | servidor[type]=generic | ||
+ | |||
+ | servidor[eth0]=link:ip=10.0.0.1/24 | ||
+ | |||
+ | servidor[dhcp]=eth0:range=10.0.0.10,10.0.0.20:default-lease=7200:gateway=10.0.0.254 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | O primeiro parâmetro na definição do atributo ''dhcp'', como exemplificado acima, diz respeito à interface de rede onde serão atendidas requisições vindas de clientes DHCP. Mais de uma interface de rede pode ser servida, bastando definir novamente o atributo ''dhcp'' para cada interface. Os demais parâmetros seguem explicados na tabela abaixo: | ||
+ | |||
+ | {| border="1" cellpadding="2" | ||
+ | !Parâmetro | ||
+ | !Descrição | ||
+ | !Exemplo | ||
+ | |- | ||
+ | |range || A faixa de endereços IP a ser concedida aos clientes. Deve ser definida com um par de endereços IP separados por vírgula || range=10.0.0.10,10.0.0.20 | ||
+ | |- | ||
+ | |gateway || O endereço IP do gateway default da subrede a ser informado aos clientes. Se for omitido, o endereço IP da interface de rede que recebeu a requisição do cliente será informado como gateway default. || gateway=10.0.0.254 | ||
+ | |- | ||
+ | |default-lease || A duração da concessão de um endereço para um cliente (em segundos). Se for omitido, será usado o valor de 600 segundos.|| default-lease=600 | ||
+ | |- | ||
+ | |max-lease || A duração máxima da concessão de um endereço para um cliente (em segundos). Se for omitido, será usado o valor de 3600 segundos.|| max-lease=3600 | ||
+ | |} | ||
+ | |||
+ | ===== Limitação de banda nas interfaces de rede ===== | ||
+ | |||
+ | A taxa de bits máxima em cada interface de rede pode ser limitada por meio do atributo ''rate''. Esse atributo tem como argumento um valor inteiro, que corresponde à taxa em kbps (kilobits por segundo) permitida na interface. | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # interface eth0 de pc1 tem taxa limitada a 256 kbps | ||
+ | pc1[eth0]=lan1:ip=192.168.0.1/24:rate=256 | ||
+ | |||
+ | # interface eth0 de pc2 tem taxa limitada a 512 kbps | ||
+ | pc2[eth0]=lan1:ip=192.168.0.1/24:rate=512 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ==== IPv6 ==== | ||
+ | |||
+ | Endereços IPv6 podem ser atribuídos às interfaces de rede de forma similar a endereços IPv4, porém usando-se o atributo ''ipv6'': | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[eth0]=lan0:ipv6=aa::1/64 | ||
+ | pc2[eth0]=lan0:ipv6=aa::2/64 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | As regras para escrever endereços IPv6 compactos são válidas para o atributo ''ipv6''. Assim, endereços como ''::1/80'', ''aa:bb::6/64'', ''aa:bb:ccdd:1234:33:8899:1122:6677/80'' são possíveis de serem usados. | ||
+ | |||
+ | |||
+ | Endereços IPv6 são automaticamente habilitados nas interfaces. Mesmo que não seja configurado explicitamente, cada interface terá seu endereço IPv6 em escopo local. Par desativar completamente o uso de IPv6 em uma interface, deve-se usar o atributo ''noipv6'': | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[eth0]=lan0:ip=10.0.0.1/24:noipv6 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | Nesse exemplo, a interface ''eth0'' de pc1 possui um endereço IPv4, porém endereços IPv6 estão desativados. | ||
+ | |||
+ | ==== Rotas estáticas ==== | ||
+ | |||
+ | Rotas estáticas para redes IPv4 ou IPv6 podem ser adicionadas a qualquer máquina virtual usando o atributo ''route'': | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[route]=192.168.0.0/24:gateway=192.168.10.10 | ||
+ | pc1[route]=172.18.0.0/16:gateway=192.168.10.1 | ||
+ | pc1[route]=default:gateway=192.168.10.2 | ||
+ | |||
+ | # Rotas IPv6 ... note o uso de default6 para a rota default IPv6 | ||
+ | pc1[route]=default6:gateway=a:b::1 | ||
+ | pc1[route]=cc:ab::/64:gateway=a:b::1 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | No exemplo acima foram adicionadas três rotas estáticas IPv4 ao computador ''pc1''. A primeira tem como destino a rede ''192.168.0.0/24'', que deve ser alcançada via gateway ''192.168.10.10''. A segunda aponta a rede ''172.18.0.0/16'' e usa o gateway ''192.168.10.1''. A terceira é a rota default. No caso de rotas IPv6, note que deve-se usar a palavra-chave '''default6''' para a rota default. | ||
+ | |||
+ | ===== Autoconfiguração de endereços e descoberta automática de gateway IPv6 com radvd ===== | ||
+ | |||
+ | No caso de redes IPv6, é possível usar o serviço [http://manpages.ubuntu.com/manpages/precise/man8/radvd.8.html radvd] para a descoberta automática de gateway da rede. Esse serviço possibilita também a configuração automática de endereço IPv6 das interfaces dos computadores de uma rede, como resumido no [http://manpages.ubuntu.com/manpages/precise/man8/radvd.8.html manual do radvd]: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | radvd is the router advertisement daemon for IPv6. It listens to router solicitations and sends router advertisements | ||
+ | as described in "Neighbor Discovery for IP Version 6 (IPv6)" (RFC 4861). With these advertisements | ||
+ | hosts can automatically configure their addresses and some other parameters. They also can choose a default | ||
+ | router based on these advertisements. | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Para usar o '''radvd''', deve-se ativá-lo no gateway da rede para cada interface de rede onde se desejam fazer os anúncios: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # radvd somente pode ser ativado em gateways (isso inclui router e outros tipo descendentes de gateway) | ||
+ | r1[type]=gateway | ||
+ | |||
+ | r1[eth0]=link1:ipv6=a:b::1/64 | ||
+ | r1[eth1]=link2:ipv6=d:e::fe/64 | ||
+ | |||
+ | # ativa o radvd na interface eth0. Os atributos ''min_interval'', ''max_interval'' e ''rdnss'' são opcionais. | ||
+ | r1[radvd]=eth0:min_interval=3:max_interval=10:rdnss=a:b::1 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A configuração criada automaticamente para o ''radvd'' é simplificada. O exemplo acima geraria o seguinte arquivo de configuração [http://manpages.ubuntu.com/manpages/precise/man5/radvd.conf.5.html /etc/radvd.conf]: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | interface eth0 { | ||
+ | AdvSendAdvert on; | ||
+ | MinRtrAdvInterval 3; | ||
+ | MaxRtrAdvInterval 10; | ||
+ | prefix a:b:0:0:0:0:0:0/64 { | ||
+ | AdvOnLink on; | ||
+ | AdvAutonomous on; | ||
+ | }; | ||
+ | RDNSS a:b::1 {}; | ||
+ | }; | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | Do lado do cliente, nada é necessário fazer para que sua interface seja automaticamente configurada. Porém caso se queria a descoberta do servidor DNS na rede IPv6, deve-se ativar o serviço ''rdnssd'', como no exemplo a seguir: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # declara uma interface no link denominado "lan". Note que não se declara a configuração | ||
+ | # do endereço IPv6 | ||
+ | pc[eth0]=lan | ||
+ | |||
+ | # ativa o serviço rdnssd no host "pc" | ||
+ | pc[services]=rdnssd | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | '''OBS:''' para que o serviço ''rdnssd'' descubra o servidor DNS, o anúncio de servidores DNS deve ser ativado no serviço ''radvd'' do gateway da rede. | ||
+ | |||
+ | ===== Rotas estáticas via interfaces PPP ===== | ||
+ | |||
+ | No caso de interfaces PPP, rotas estáticas devem obrigatoriamente ser especificadas da seguinte forma: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[route]=192.168.0.0/24:dev=ppp0 | ||
+ | |||
+ | # Ou no caso de rota IPv6 | ||
+ | pc1[route]=aa:bb::/64:dev=ppp0 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A diferença está no fato de que se deve indicar a interface de saída da rota ao invés do ''gateway''. | ||
+ | |||
+ | ===== Rotas default (rota padrão) ===== | ||
+ | |||
+ | A rota default é um caso especial, e por ser bastante comum existe um atributo específico para sua definição: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[default_gateway]=192.168.0.254 | ||
+ | |||
+ | # Ou no caso de IPv6 | ||
+ | pc1[default_gateway]=aa:bb::1 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | No exemplo acima, o computador ''pc1'' definiu que seu roteador default deve ser 192.168.0.254. Essa forma curta de definir a rota default funciona somente para rotas que passam por gateways. No caso de rotas por interfaces, deve-se adicioná-las com o atributo ''route''. | ||
+ | |||
+ | '''OBS:''' no caso de interfaces PPP, não se pode especificar uma rota ''default'' com a sintaxe acima. Para essas interfaces, deve-se usar a sintaxe para rotas estáticas em geral: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[route]=0.0.0.0/0:dev=ppp0 | ||
+ | |||
+ | # Ou no caso de IPv6 | ||
+ | pc1[route]=::/0:dev=ppp0 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ... ou: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[route]=default:dev=ppp0 | ||
+ | |||
+ | # No caso de IPv6 | ||
+ | pc1[route]=default6:dev=ppp0 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ==== Enlaces ponto-a-ponto (via portas seriais) ==== | ||
+ | |||
+ | No caso de uma rede em que máquinas virtuais se comunicam via portas seriais efetuando enlaces ponto-a-ponto, uma sintaxe ligeiramente diferente deve ser usada em ''Lab.conf'': | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | |||
+ | pc1[ppp0]=link0:ip=10.0.0.1/30 | ||
+ | pc2[ppp0]=link0:ip=10.0.0.2/30 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A diferença está no nome da interface, que deve ser ''ppp0''. Múltiplas interfaces ponto-a-ponto podem existir em cada máquina virtual. Ao iniciarem, as máquinas virtuais terão suas interfaces seriais interligadas. Essas interfaces dentro do Linux são identificadas por ''/dev/ttyS0'', ''/dev/ttyS1'', ''/dev/ttyS3'', e assim por diante (similar a ''COM1, COM2, COM3, ...'' do Windows). Assim, dentro das máquinas virtuais podem-se criar enlaces PPP usando-se essas interfaces seriais. No exemplo acima, como foi definido o IP de cada interface ponto-a-ponto, o protocolo PPP será automaticamente ativado quando as máquinas virtuais iniciarem. | ||
+ | |||
+ | |||
+ | Interfaces PPP podem ter endereços IPv4 e IPv6 (ambos ou apenas um deles). | ||
+ | |||
+ | |||
+ | A emulação do enlace via portas seriais pode também simular propriedades de enlaces reais, tais como taxa de bits, atraso de propagação e taxa de erros de bit (BER). No exemplo anterior essas propriedades não foram especificadas, então a taxa de bits ficou limitada pelo computador, e o atraso de propapagação e BER foram nulos. Caso se deseje definir uma ou mais dessas propriedades, devem-se usar as opções ''rate'', ''delay'' e ''ber'' na configuração do enlace ponto-a-ponto, como mostrado abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # rate: definida em bits por segundo (bps) | ||
+ | # delay: dado em milissegundos (ms) | ||
+ | # ber: valor entre 0 e 1 | ||
+ | pc1[ppp0]=link0:ip=10.0.0.1/30:rate=64000:delay=100:ber=0.000001 | ||
+ | pc2[ppp0]=link0:ip=10.0.0.2/30:rate=64000:delay=100:ber=0.000001 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Nesse exemplo, o enlace ''link0'' tem taxa de 64000 bps, atraso de propagação de 100 ms e BER de <math>10^{-6}</math>. Observe que uma ou mais dessas propriedades pode ser omitida, e que basta defini-las em uma das pontas do enlace. | ||
+ | |||
+ | |||
+ | '''OBS:''' para poder usar o wireshark em uma interface PPP, ela deve ter ativada a opção ''debug'': | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # A interface ppp0 de pc1 pode ter seu tráfego analisado com wireshark | ||
+ | pc1[ppp0]=link0:ip=10.0.0.1/30:debug=1 | ||
+ | |||
+ | # a ppp0 de pc2 não ... | ||
+ | pc2[ppp0]=link0:ip=10.0.0.2/30 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ===== Usando a porta serial da máquina real ===== | ||
+ | |||
+ | Pode-se vincular uma interface serial de uma máquina virtual a uma porta serial da máquina real. Com isso, é possível estabelecer enlaces PPP entre máquinas virtuais que estão em diferentes computadores. Esses computadores devem ter suas interfaces seriais RS-232 interligadas por um cabo serial ''cross''. Essa vinculação é feita quando se escreve o nome de uma interface serial da máquina real no lugar do link, ao se declarar uma interface PPP: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[type]=generic | ||
+ | |||
+ | # A interface ppp0 de pc1 está vinculada à interface ttyS0 da máquina real | ||
+ | pc1[ppp0]=ttyS0:ip=10.0.0.1/30 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ''OBS:'' as interfaces seriais são chamadas de ''ttyS0'' (equivalente a COM1 do DOS/Windows), ''ttyS1'' (equivalente a COM2), e assim por diante. | ||
+ | |||
+ | ==== Iniciando serviços de rede automaticamente ==== | ||
+ | |||
+ | Serviços de rede, tais como os oferecidos pelos servidores SSH, Apache2 e outros, podem ser iniciados automaticamente usando-se o atributo ''services'': | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc[services]=apache2:ssh | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Os serviços a serem iniciados devem estar separados por '':''. | ||
+ | |||
+ | Observe que as configurações desses serviços poderão precisar ser ajustadas, dependendo de como se deseja que eles operem. | ||
+ | |||
+ | ==== Arquivos de projeto do Netkit: preservando modificações feitas nas máquinas virtuais ==== | ||
+ | |||
+ | No arquivo de configuração do Netkit (ex: Lab.conf) devem-se listar os diretorios e/ou arquivos a serem preservados em cada vm (pode haver vm sem o que preservar). Assim, ao | ||
+ | iniciar a rede cada máquina virtual pode recuperar os arquivos preservados, e ao terminar os salva automaticamente. Por exemplo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | |||
+ | pc1[eth0]=link0:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=link0:ip=192.168.0.2/24 | ||
+ | |||
+ | pc1[preserve]=/etc:/usr/local/etc | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ... vai preservar os diretorios /etc e /usr/local/etc de ''pc1'', porém em ''pc2'' nada será preservado. Os diretorios e arquivos a serem | ||
+ | preservados devem estar separados por ":". Quanto mais específicos forem os diretórios listados, menor será a quantidade de arquivos a | ||
+ | serem preservados. | ||
+ | |||
+ | Para facilitar a cópia da configuração de uma rede virtual, a qual inclui esses arquivos preservados, existem os ítens "Export" e "Import" no menu "File". Ao clicar em "Export", pode-se salvar em um subdiretório qualquer todo um projeto do Netit, o qual é chamado de "Netkit Project File". O nome desses arquivo de projeto é obtido do arquivo de configuração da rede, porém com extensão ".netkit". Ao clicar em "Import" pode-se escolher um projeto salvo previamente, tendo como efeito a restauração dos arquivos preservados das máquinas virtuais e a | ||
+ | carga automática do arquivo de configuração. Com isso pode-se copiar o arquivo de projeto entre diferentes computadores, tornando possível reproduzir fielmente uma rede virtual criada e configurada previamente. | ||
+ | |||
+ | '''IMPORTANTE:''' somente deve-se exportar o arquivo de projeto APÓS terminar a execução da rede virtual. | ||
+ | |||
+ | === Gateways (computadores que interligam subredes) === | ||
+ | |||
+ | Neste outro exemplo (contido [http://tele.sj.ifsc.edu.br/~msobral/netkit/lab2.tar.gz neste arquivo]), o computador ''pc2'' funciona como gateway entre os computadores ''pc1'' e ''pc3''. | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=gateway | ||
+ | pc3[type]=generic | ||
+ | pc1[default_gateway]=192.168.0.2 | ||
+ | pc3[default_gateway]=192.168.1.2 | ||
+ | |||
+ | pc1[eth0]=lan0:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=lan0:ip=192.168.0.2/24 | ||
+ | pc2[eth1]=lan1:ip=192.168.1.2/24 | ||
+ | pc3[eth0]=lan1:ip=192.168.1.3/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A rede resultante é: | ||
+ | |||
+ | [[imagem:netkit-lab2.png]] | ||
+ | |||
+ | ==== NAT ==== | ||
+ | |||
+ | NAT pode ser ativado em máquinas virtuais do tipo ''gateway''. Em sua configuração deve-se informar qual a interface de saída onde será feito o NAT: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc2[type]=gateway | ||
+ | |||
+ | pc2[nat]=eth1 | ||
+ | </syntaxhighlight> | ||
+ | Assim, todos datagramas que sairem pela interface ''eth1'' do gateway ''pc2'' terão seus endereços IP de origem substituídos pelo endereço IP dessa interface. | ||
+ | |||
+ | ==== Uplink para a rede real ==== | ||
+ | |||
+ | O Netkit possibilita que se criem links para a rede real, e com isto as máquinas virtuais podem acessar a rede externa e mesmo a Internet. No entanto, o contrário é um pouco mais difícil (se bem que não impossível) devido a forma como o acesso à rede real foi implementado. O link para a rede real funciona como um enlace ponto-a-ponto ethernet entre uma máquina virtual e a máquina real (o sistema hospedeiro), como pode ser visto neste exemplo: | ||
+ | |||
+ | [[imagem:Netkit-uplink.png]] | ||
+ | |||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=gateway | ||
+ | |||
+ | pc1[default_gateway]=192.168.0.2 | ||
+ | pc2[default_gateway]=10.0.0.2 | ||
+ | |||
+ | pc1[eth0]=link1:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=link1:ip=192.168.0.2/24 | ||
+ | pc2[eth1]=uplink:ip=10.0.0.1/30 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A criação do link para rede externa deve ser feita com o link especial ''uplink''. Ele deve ter um endereço IP que será usado somente para criar o link entre a máquina virtual e o sistema hospedeiro. O IP no sistema hospedeiro é sempre o último endereço possível dentro da subrede especificada (no exemplo, seria o IP 10.0.0.2). | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc2[eth1]=uplink:ip=10.0.0.1/30 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Se outras máquinas virtuais precisarem acessar a rede externa, devem ter rotas configuradas para usarem o gateway onde foi feito o ''uplink''. Além disso, será necessário ativar o NAT nesse gateway. | ||
+ | |||
+ | Por fim, a criaçao do ''uplink'' implica executar alguns comandos como ''root'' no sistema hospedeiro. Assim, ao ativar a rede o Netkit irá usar o ''sudo'' para executar esses comandos. Por isso é possível que a sua senha seja solicitada durante a inicialização da rede virtual. | ||
+ | |||
+ | ===== Uplink em modo ''bridge'' ===== | ||
+ | |||
+ | Às vezes uma interface de uma máquina virtual precisa ser exposta na rede real, como se ela pertencesse ao sistema hospedeiro. Neste caso, deve-se criar uma ''bridge'' entre a interface da máquina virtual e uma interface real do sistema hospedeiro (de forma semelhante ao que faz o Virtualbox e outros tipos de máquinas virtuais). Uma ''bridge'' é um mecanismo existente no Linux para interligar interfaces ethernet em nível de enlace, como se elas formassem um ''switch''. O procedimento para criar uma ''bridge'' integrada a uma interface do tipo ''uplink'' do Netkit é um tanto trabalhoso, e por isso esse processo foi automatizado. | ||
+ | |||
+ | A criação de um ''uplink'' em modo bridge deve ser feita usando o parâmetro ''bridge'' ao se declarar uma interface de rede, como mostrado abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc[eth0]=uplink:bridge=eth0:ip=192.168.1.100/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Neste exemplo, será criada uma ''bridge'' entre a interface ''eth0'' da máquina virtual ''pc'' e a interface ''eth0'' do sistema hospedeiro. Como com isso a interface da máquina virtual estará exposta na rede real, seu endereço IP pode pertencer à subrede da rede real. Se esse endereço IP for de alguma outra subrede, a máquina virtual não conseguirá se comunicar com as máquinas reais, tampouco acessar a Internet. Mas isso pode ser desejável se a intenção for interligar redes virtuais que estejam sendo executadas em diferentes computadores. | ||
+ | |||
+ | Outra possibilidade é configurar a interface com '''DHCP''': | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc[eth0]=uplink:bridge=eth0:ip=dhcp | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Desta forma, a interface obterá um endereço IP (além de rota default e servidor DNS) do servidor DHCP da rede real. | ||
+ | |||
+ | Por fim, é possível definir uma interface sem endereço IP: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc[eth0]=uplink:bridge=eth0 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | === PBX IP (Asterisk) === | ||
+ | |||
+ | O Netkit possui um tipo de máquina virtual especial para funcionar como um PBX Asterisk. As diferenças entre esse tipo de máquina e ''gateway'' é a quantidade de memória a ela reservada (64 MB) e a instalação automática do software Asterisk. Todos os arquivos do Asterisk estão dentro de ''/usr/local/asterisk''. Abaixo há um exemplo de uma rede com um PBX: | ||
+ | |||
+ | [[imagem:Pbx-netkit.png]] | ||
+ | <br>''Uma pequena rede com um PBX IP'' | ||
+ | |||
+ | A configuração dessa rede está mostrada a seguir: | ||
+ | <syntaxhighlight lang=text> | ||
+ | global[compact]=True | ||
+ | # | ||
+ | pbx[type]=pbx | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | # | ||
+ | pbx[eth0]=link1:ip=192.168.1.254/24 | ||
+ | pbx[eth1]=link2:ip=192.168.2.254/24 | ||
+ | pc1[eth0]=link1:ip=192.168.1.1/24 | ||
+ | pc2[eth0]=link2:ip=192.168.2.1/24 | ||
+ | |||
+ | pc1[default_gateway]=192.168.1.254 | ||
+ | pc2[default_gateway]=192.168.2.254 | ||
+ | pbx[preserve]=/usr/local/asterisk/etc | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | O Asterisk instalado no PBX tem somente canais SIP e IAX2, porém isso é suficiente para realizar muitos experimentos sobre VoIP. Note que na configuração do experimento mostrada acima incluiu-se uma opção para preservar os arquivos contidos em ''/usr/local/asterisk/etc''. Isso é fortemente recomendado, para que as configurações feitas nos canais SIP e IAX2, além do plano de discagem, não sejam perdidos ao se encerrar a execução da rede. Porém para que esses arquivos sejam realmente preservados, deve-se exportar o experimento logo após parar a rede, conforme explicado na [[Netkit#Arquivos_de_projeto_do_Netkit:_preservando_modifica.C3.A7.C3.B5es_feitas_nas_m.C3.A1quinas_virtuais|seção sobre preservação de arquivos]]. | ||
+ | |||
+ | '''OBS:''' o Asterisk não é iniciado automaticamente. Para iniciá-lo execute: <syntaxhighlight lang=bash> | ||
+ | /usr/local/asterisk/sbin/asterisk | ||
+ | </syntaxhighlight> | ||
+ | ... ou declare-o no arquivo de configuração do Netkit como um serviço a ser iniciado: <syntaxhighlight lang=text> | ||
+ | pbx[services]=asterisk | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ...e para monitorá-lo (abrir seu console): <syntaxhighlight lang=bash> | ||
+ | /usr/local/asterisk/sbin/rasterisk -vvv | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ==== Realizando chamadas VoIP no Netkit ==== | ||
+ | |||
+ | Um experimento sobre VoIP implica serem feitas chamadas para se testarem as configurações do PBX e para estudar o funcionamento dos protocolos envolvidos. Porém o uso de ''softphones'' dentro do Netkit é impraticável, visto que as máquinas virtuais não foram feitas para terem acesso ao microfone e alto-falante (tampouco apresentam ambiente gráfico, o que limita os ''softphones'' que poderiam ser usados). Como o objetivo do Netkit é ajudar a criar redes virtuais e realizar experimentos com aplicações que usem essas redes, seria suficiente simular chamadas VoIP para estudar a sinalização e o transporte das streams de audio. Desta forma, no Netkit foram instalados os softwares [http://www.pjsip.org/pjmedia/docs/html/page_pjmedia_samples_siprtp_c.htm siprtp] e [http://www.pjsip.org/pjsua.htm pjsua], que fazem parte do projeto [http://www.pjsip.org/ PJSIP] (um conjunto de programas de teste e avaliação de desempenho para infraestruturas VoIP baseadas em SIP), e também o software [http://sipp.sourceforge.net/doc/reference.html#Using+SIPp sipp]. | ||
+ | * '''siprtp''': esse programa possibilita fazer chamadas com áudio sintetizado, no entanto possui algumas restrições para ser usado com o Asterisk. | ||
+ | * '''pjsua''': esse programa é mais completo, sendo capaz de realizar chamadas muito próximas do real. Ele é até capaz de gerar o audio a partir de arquivos de som. Ao contrário do ''siprtp'', o ''pjsua'' é capaz de se registrar no Asterisk. | ||
+ | ** [http://www.pjsip.org/pjsua.htm Manual do pjsua] | ||
+ | * [http://sipp.sourceforge.net/doc/reference.html sipp]: mais um programa capaz de fazer muitos testes de conformidade e capacidade em chamadas SIP. | ||
+ | |||
+ | ===== Usando o siprtp ===== | ||
+ | |||
+ | O programa ''siprtp'' funciona em modo cliente-servidor: em um computador executa-se o programa em modo servidor (aguardando chamadas), e no outro executa-se em modo cliente (iniciando chamadas). As chamadas podem ser feitas diretamente ou com a intermediação de um ou mais PBX IP. O exemplo abaixo mostra os comandos necessários para se fazer uma chamada direta entre cliente e servidor: | ||
+ | |||
+ | {| border="1" cellpadding="2" | ||
+ | !Servidor | ||
+ | !Cliente | ||
+ | |- | ||
+ | |siprtp -i IP_do_servidor || siprtp -i IP_do_cliente <nowiki>sip:0@IP_do_servidor</nowiki> | ||
+ | |} | ||
+ | |||
+ | Chamadas que usam PBX como intermediários podem também ser realizadas, porém há alguns cuidados a tomar para que funcionem a contento: | ||
+ | * ''siprtp'' não faz registro SIP no PBX, portanto a configuração dos canais SIP no PBX deve informar os endereços IP dos computadores onde estão tanto cliente quanto servidor. No Asterisk isso se faz com o parâmetro ''host'' de um canal SIP, definido no arquivo ''sip.conf'': <syntaxhighlight lang=text> | ||
+ | [1234] | ||
+ | type=friend | ||
+ | username=1234 | ||
+ | host=IP_do_computador_onde_roda_o_siprtp | ||
+ | #secret=ultrasecreta ; não precisa de senha ... | ||
+ | insecure=port,invite | ||
+ | context=default | ||
+ | allow=alaw | ||
+ | allow=ulaw | ||
+ | qualify=yes | ||
+ | </syntaxhighlight> | ||
+ | * ''siprtp'' não aceita RE-INVITE, portanto deve-se desativar essa funcionalidade no Asterisk. Na seção ''[general]'' do arquivo ''sip.conf'' deve-se incluir esta opção: <syntaxhighlight lang=text> | ||
+ | directmedia=no | ||
+ | </syntaxhighlight> | ||
+ | * O cliente deve especificar o canal SIP e o endereço IP do PBX ao fazer uma chamada. Por exemplo, para fazer uma chamada para o canal ''1234'' deve-se executar o seguinte: <syntaxhighlight lang=bash> | ||
+ | siprtp -i IP_do_cliente sip:1234@IP_do_PBX | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ===== Usando o pjsua ===== | ||
+ | |||
+ | O pjsua possui muitas funcionalidades que o tornam um agente SIP quase completo (faltaria ao menos suportar re-invite). Para usá-lo existem muitas opções de linha de comando, conforme descrito em [http://www.pjsip.org/pjsua.htm seu manual]. Aqui se demonstra como fazer uma chamada com dois pjsua registrados em um PBX Asterisk. | ||
+ | |||
+ | # Inicie o Asterisk no PBX, executando este comando: <syntaxhighlight lang=bash> | ||
+ | asterisk | ||
+ | rasterisk -vvv | ||
+ | </syntaxhighlight>''Obs: "rasterisk -vvv" serve somente para que você possa monitorar o funcionamento do Asterisk'' | ||
+ | # Em cada máquina virtual ''fone'' pode ser criado um arquivo ''/root/pjsua.cfg'', que contém configurações usuais para rodar o pjsua (ver [[Netkit#Ajustes_na_configura.C3.A7.C3.A3o_do_pjsua|exemplo mais à frente]]). Desta forma, evita-se ter que digitá-las sempre que se iniciar o programa. Deve-se executar o pjsua da seguinte forma para que use esse arquivo de configuração: <syntaxhighlight lang=bash> | ||
+ | pjsua --config-file=/root/pjsua.cfg | ||
+ | </syntaxhighlight> | ||
+ | # O arquivo de configuração tenta registrar automaticamente o pjsua no Asterisk. A conta SIP pre-configurada para fins de demonstração é ''sip:100@ifsc.edu.br'' (mude-a de acordo com o seu experimento). | ||
+ | # Ao rodar o pjsua, confira no PBX se ele foi devidamente registrado. Assim, execute o seguinte no prompt do rasterisk desse PBX: <syntaxhighlight lang=bash> | ||
+ | sip show peers | ||
+ | </syntaxhighlight>O resultado deve ser parecido com este (neste exemplo, foram ativados dois pjsua), em que se nota o Status ''OK'' para as contas SIP:<br><br>[[imagem:Rasterisk1.png|600px]]<br><br> | ||
+ | # A tela do pjsua mostra um menu com os comandos que podem ser usados, como mostrado na seguinte figura: <br><br>[[imagem:Pjsua1.png|600px]]<br><br> | ||
+ | # Para fazer uma chamada, use o comando '''m'''. Ao digitá-lo e teclar ENTER, será pedida a URL do contato a ser chamado: <br><br>[[imagem:Pjsua2.png|600px]]<br><br> | ||
+ | # Uma vez tendo a chamada estabelecida, pode-se usar o comando '''dq''' para monitorar a qualidade da comunicação:<br><br>[[imagem:Pjsua3.png|600px]]<br><br> | ||
+ | # Para encerrar a chamada, use o comando '''ha'''. | ||
+ | |||
+ | ====== Ajustes na configuração do pjsua ====== | ||
+ | |||
+ | O arquivo de configuração pjsua.cfg que foi fornecido contém configuração de demonstração. Ao fazer as suas modificações nas configurações dos PBX para realizar o trabalho, será necessário também ajustar esse arquivo. Abaixo segue o conteúdo do pjsua.cfg que está em ''fone1'' (os números das linhas são apenas informativos, e não fazem parte do ''pjsua.cfg''): | ||
+ | |||
+ | <syntaxhighlight lang=text n> | ||
+ | # | ||
+ | # User agent: | ||
+ | # | ||
+ | --auto-answer 200 | ||
+ | --max-calls 4 | ||
+ | --registrar sip:192.168.1.100 | ||
+ | --proxy sip:192.168.1.100;lr | ||
+ | --realm * | ||
+ | # Abaixo devem ser especificados os dados da conta SIP | ||
+ | --id sip:100@ifsc.edu.br | ||
+ | --username 100 | ||
+ | --password 100 | ||
+ | |||
+ | # | ||
+ | # Logging options: | ||
+ | # | ||
+ | --log-level 3 | ||
+ | --app-log-level 4 | ||
+ | |||
+ | # | ||
+ | # Network settings: | ||
+ | # | ||
+ | --local-port 5060 | ||
+ | |||
+ | # | ||
+ | # Media settings: | ||
+ | # | ||
+ | --null-audio | ||
+ | --snd-auto-close 1 | ||
+ | --rtp-port 4000 | ||
+ | |||
+ | # | ||
+ | # SIP extensions: | ||
+ | # | ||
+ | --use-timer 1 | ||
+ | |||
+ | # Desativa deteccao de silencio | ||
+ | --no-vad | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | O que pode ser necessário modificar são os dados da conta SIP a ser usada pelo pjsua. Isso é especificado nas linhas 10, 11 e 12. | ||
+ | |||
+ | ===== Usando o sipp ===== | ||
+ | |||
+ | A [http://sipp.sourceforge.net/doc/reference.html#Using+SIPp documentação do SIPp] mostra vários exemplos e detalha como se podem criar os cenários de teste. Existe também um pequeno manual que pode ser lido com este comando: | ||
+ | |||
+ | <syntaxhighlight lang=bash> | ||
+ | man sipp | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | === Switches === | ||
+ | |||
+ | Switches são implementados usando funcionalidades existentes no Linux. Assim, uma máquina virtual devidamente configurada pode se comportar como um switch. As funcionalidades possibilitam fazer experiências com [http://pt.wikipedia.org/wiki/IEEE_802.1Q VLANs IEEE 802.1q], agregação de enlaces [http://en.wikipedia.org/wiki/Link_aggregation IEEE 802.1AX], e mesmo com [http://pt.wikipedia.org/wiki/Spanning_Tree_Protocol STP IEEE 802.1d]. | ||
+ | |||
+ | Um switch com 4 portas pode ser criado da seguinte forma: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | nome[type]=switch | ||
+ | |||
+ | nome[eth0]=port0 | ||
+ | nome[eth1]=port1 | ||
+ | nome[eth2]=port2 | ||
+ | nome[eth3]=port3 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Sendo: | ||
+ | * '''nome:''' nome da maquina virtual | ||
+ | |||
+ | O exemplo com um switch (ver [[Netkit#Uma_biblioteca_de_exemplos_de_experimentos|a biblioteca de exemplos mais abaixo]]) mostra como criar uma pequena LAN com switch. Note que a máquina virtual que será o switch (chamada aqui convenientemente de ''switch'') deve declarar suas interfaces normalmente, além de definir que elas operam em modo bridge (i.e. como um switch): | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | switch[type]=switch | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | pc3[type]=generic | ||
+ | pc4[type]=generic | ||
+ | |||
+ | switch[eth0]=port0 | ||
+ | switch[eth1]=port1 | ||
+ | switch[eth2]=port2 | ||
+ | switch[eth3]=port3 | ||
+ | |||
+ | pc1[eth0]=port0:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=port1:ip=192.168.0.2/24 | ||
+ | pc3[eth0]=port2:ip=192.168.0.3/24 | ||
+ | pc4[eth0]=port3:ip=192.168.0.4/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | ==== VLANs ==== | ||
+ | |||
+ | Um switch pode ter também suas portas em diferentes vlans. Assim, no exemplo abaixo cria-se um switch com 4 portas, porém com 2 portas na vlan 5 e duas na vlan 10 (todas em modo ''untagged''): | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | nome[type]=switch | ||
+ | |||
+ | nome[eth0]=port0:vlan_untagged=5 | ||
+ | nome[eth1]=port1:vlan_untagged=10 | ||
+ | nome[eth2]=port2:vlan_untagged=10 | ||
+ | nome[eth3]=port3:vlan_untagged=5 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Sendo: | ||
+ | * '''nome:''' nome da maquina virtual | ||
+ | * '''vlan_untagged:''' especifica o número de uma VLAN em modo ''untagged'' a que pertence a interface de rede em questão. | ||
+ | |||
+ | A configuração acima vai criar uma bridge para cada conjunto de interfaces que estão na mesma VLAN. Nesse exemplo as interfaces operam todas em modo ''untagged'', mas se for necessário que operem em modo ''tagged'' deve-se fazer da seguinte forma: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | nome[type]=switch | ||
+ | |||
+ | nome[eth0]=port0:vlan_tagged=10,20 | ||
+ | nome[eth1]=port1:vlan_untagged=10 | ||
+ | nome[eth2]=port2:vlan_untagged=10 | ||
+ | nome[eth3]=port3:vlan_untagged=5 | ||
+ | nome[eth4]=port4 | ||
+ | nome[eth5]=port5 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | No exemplo acima, a interface eth0 estará nas VLANs 10 e 20 em modo ''tagged''. No caso de interfaces em que não se especificam as vlans, como eth4 e eth5, o switch assume implicitamente que estão na vlan 1 e em modo ''untagged''. | ||
+ | |||
+ | Com base nos exemplos acima, a sintaxe para definir as VLANs em uma interface de rede de uma máquina virtual deve ser: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | nome_vm[nome_iface]=nome_link:vlan_untagged=num_vid:vlan_tagged=num_vid1,num_vid2,... | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ... sendo que tanto ''vlan_untagged'' quanto ''vlan_tagged'' podem ser omitidos, mas não podem ser usados ao mesmo tempo. | ||
+ | |||
+ | Um outro exemplo (também encontrado na [[Netkit#Uma_biblioteca_de_exemplos_de_experimentos|biblioteca de exemplos]]) mostra um switch com duas VLANs, e o computador ''pc4'' atuando como gateway entre as VLANs. O gateway usa duas interfaces virtuais, e assim a porta do switch em que ele está conectado deve operar em modo tagged: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | switch[type]=switch | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | pc3[type]=generic | ||
+ | pc4[type]=gateway | ||
+ | pc5[type]=generic | ||
+ | pc6[type]=generic | ||
+ | pc7[type]=generic | ||
+ | |||
+ | switch[eth0]=port0:vlan_untagged=5 | ||
+ | switch[eth1]=port1:vlan_untagged=5 | ||
+ | switch[eth2]=port2:vlan_untagged=5 | ||
+ | switch[eth3]=port3:vlan_tagged=5,10 | ||
+ | switch[eth4]=port4:vlan_untagged=10 | ||
+ | switch[eth5]=port5:vlan_untagged=10 | ||
+ | switch[eth6]=port6:vlan_untagged=10 | ||
+ | |||
+ | pc1[eth0]=port0:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=port1:ip=192.168.0.2/24 | ||
+ | pc3[eth0]=port2:ip=192.168.0.3/24 | ||
+ | pc4[eth0]=port3:vlan_tagged=(5,ip=192.168.0.4/24),(10,ip=192.168.1.4/24) | ||
+ | pc5[eth0]=port4:ip=192.168.1.5/24 | ||
+ | pc6[eth0]=port5:ip=192.168.1.6/24 | ||
+ | pc7[eth0]=port6:ip=192.168.1.7/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Esse exemplo mostra que podem-se definir diretamente os endereços IP das interfaces de rede virtuais. Isso é útil para o caso de se definirem interfaces virtuais em máquinas virtuais do tipo ''generic'', ''gateway'' e ''router'' (não tem sentido usar isso em ''switch''). No entanto, a sintaxe nesse caso é ligeiramente diferente, pois deve-se colocar entre parênteses o número da vlan e o IP da interface, como destacado abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc4[eth0]=port3:vlan_tagged=(5,ip=192.168.0.4/24),(10,ip=192.168.1.4/24) | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ==== STP (Spanning Tree Protocol) ==== | ||
+ | |||
+ | Switches reais usualmente possuem suporte a [[IER-2011-1#Interliga.C3.A7.C3.A3o_de_LANs_e_Spanning_Tree_Protocol_.28STP.29|STP (''Spanning Tree Protocol'')]] para possibilitar haver enlaces redundantes em uma rede local. No Netkit podem-se criar redes em que se usa o STP, que deve ser ativado no switches. Um exemplo de rede em que o STP se torna necessário é mostrada na figura abaixo: | ||
+ | |||
+ | [[imagem:LAN-anel-stp.png]] | ||
+ | |||
+ | Para criar essa rede no Netkit pode-se usar a seguinte configuração: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw1[type]=switch | ||
+ | sw2[type]=switch | ||
+ | sw3[type]=switch | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | pc3[type]=generic | ||
+ | |||
+ | # Ativação do STP nos switches | ||
+ | sw1[stp]=on:bridge_priority=1024 | ||
+ | sw2[stp]=on:bridge_priority=128 | ||
+ | sw3[stp]=on:bridge_priority=500 | ||
+ | |||
+ | sw1[eth0]=sw1-sw2 | ||
+ | sw1[eth1]=sw1-port1 | ||
+ | sw1[eth2]=sw1-sw3 | ||
+ | sw2[eth0]=sw1-sw2 | ||
+ | sw2[eth1]=sw2-port1 | ||
+ | sw2[eth2]=sw2-sw3 | ||
+ | |||
+ | sw3[eth0]=sw1-sw3 | ||
+ | sw3[eth1]=sw3-port1 | ||
+ | sw3[eth2]=sw2-sw3 | ||
+ | |||
+ | pc1[eth0]=sw1-port1:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=sw2-port1:ip=192.168.0.2/24 | ||
+ | pc3[eth0]=sw3-port1:ip=192.168.0.3/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A configuração do STP se faz pelo atributo especial ''stp'' a ser especificado para cada switch. A opção ''on'' ativa o STP, e ''bridge_priority'' define a prioridade do switch no escopo do STP. | ||
+ | |||
+ | Como os switches podem ser configurados com múltiplas vlans, o STP deve ser ativado apropriadamente. Isso significa que cada vlan deve ter o STP rodando de forma independente. A configuração do Netkit para especificar o STP para cada vlan segue abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw1[type]=switch | ||
+ | |||
+ | # Ativação do STP nos switches | ||
+ | sw1[stp]=on:bridge_priority=1024:vlan=5 | ||
+ | sw1[stp]=on:bridge_priority=512:vlan=10 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Nesse exemplo, o switch ''sw1'' tem o STP ativado na vlans 5 e 10. Os parâmetros do STP inclusive podem ser diferentes em cada vlan, já que ele opera em cada uma de forma independente (i.e. o STP em uma vlan não interfere com o STP em outra vlan). Vlans em que o stp não foi explicitamente ativado usarão a configuração default do stp, a qual é definida omitindo-se informação sobre vlan: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # Configuração default do STP em um switch ... vale para todas as vlans em que | ||
+ | # o stp não foi configurado individualmente. | ||
+ | sw1[stp]=on | ||
+ | |||
+ | # A configuração default pode conter quaisquer opções do stp, menos vlan: | ||
+ | sw2[stp]=on:bridge_priority=2000 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Um último detalhe sobre o STP diz respeito ao custo e prioridade de cada porta do switch. No STP usado em switches reais, o custo de uma porta é dado pela sua velocidade. Assim, portas mais velozes têm custo menor que portas mais lentas, como por exemplo portas 1 Gbps comparadas a 100 Mbps. No Netkit não existe essa diferenciação entre as interfaces ethernet por serem emuladas, mas pode-se especificar manualmente o custo de cada interface a ser usado pelo STP. A configuração necessária deve ser colocada em cada porta da seguinte forma: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw1[type]=switch | ||
+ | |||
+ | # Ativação do STP nos switches | ||
+ | sw1[stp]=on:bridge_priority=1024 | ||
+ | |||
+ | sw1[eth0]=port0:stp_cost=10 | ||
+ | sw1[eth1]=port1:stp_cost=100 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Assim, nesse exemplo a interface eth0 do switch ''sw1'' tem custo STP 10, e a interface eth1 tem custo 100. Os custos de interfaces de acordo com a norma IEEE 802.1d pode ser visto na seguinte tabela: | ||
+ | |||
+ | [[imagem:Stp-custos.png]] | ||
+ | |||
+ | |||
+ | A lista completa de opções que podem ser usadas na configuração do STP no Netkit segue abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # STP no switch: | ||
+ | # bridge_priority: prioridade do switch no STP | ||
+ | # hello_time: intervalo entre envios de BPDU | ||
+ | # max_age: tempo máximo que o STP pode ficar sem receber uma atualização de BPDU de outro switch | ||
+ | # forward_delay: atraso para enviar uma BPDU notificando uma mudança de configuração do STP | ||
+ | # on: ativa o STP | ||
+ | # off: inicia com STP desativado | ||
+ | |||
+ | sw1[stp]=on:vlan=10:bridge_priority=100:hello_time=2:max_age=10:forward_delay=1 | ||
+ | |||
+ | # Porta do switch: pode ter as opções stp_cost (custo da porta) e stp_prio (prioridade da porta) | ||
+ | sw1[eth0]=port0:stp_cost=10:stp_prio=1 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ==== Controle de acesso IEEE 802.1x ==== | ||
+ | |||
+ | O controle de acesso [[RCO2-2012-1#Padr.C3.A3o_IEEE_802.1x|IEEE 802.1x]] possibilita liberar ou bloquear portas de switches mediante a identificação de usuários válidos. Para usá-lo no Netkit deve-se fazer o seguinte: | ||
+ | # Nos switches ativa-se a autenticação com IEEE 802.1x, fornecendo-se uma lista de usuários e respectivas senhas. Além disso, identificam-se quais portas dos switches que exigirão que usuários se autentiquem (portas autenticadoras). <syntaxhighlight lang=text> | ||
+ | sw[type]=switch | ||
+ | |||
+ | # Podem-se definir quantos usuários e senhas forem desejados. | ||
+ | sw[8021x]=1:users=usuario1/senha1,usuario2/senha2 | ||
+ | |||
+ | # A interface eth0 do switch é uma porta autenticadora, mas a interface eth1 não. | ||
+ | sw[eth0]=port0:8021x_authenticator=1 | ||
+ | sw[eth1]=port1 | ||
+ | </syntaxhighlight> | ||
+ | # Nos computadores que se conectarão aos switches deve-se informar o usuário e senha para fins de autenticação. <syntaxhighlight lang=text> | ||
+ | pc[type]=generic | ||
+ | |||
+ | pc[eth0]=port0:8021x_user=usuario1/senha1:ip=10.0.0.1/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Juntando os dois exemplos acima, pode-se definir uma pequena rede para fins de demonstração do controle de acesso: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw[type]=switch | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | |||
+ | # Podem-se definir quantos usuários e senhas forem desejados. | ||
+ | sw[8021x]=1:users=usuario1/senha1,usuario2/senha2 | ||
+ | |||
+ | # A interface eth0 do switch é uma porta autenticadora, mas a interface eth1 não. | ||
+ | sw[eth0]=port0:8021x_authenticator=1 | ||
+ | sw[eth1]=port1 | ||
+ | |||
+ | pc1[eth0]=port0:8021x_user=usuario1/senha1:ip=10.0.0.1/24 | ||
+ | pc2[eth0]=port1:ip=10.0.0.2/24 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Ao executar a rede acima, deve-se conseguir fazer um ping entre ''pc1'' e ''pc2''. Se quiser testar com maiores detalhes o controle de acesso e vê-lo em ação, experimente fazer o seguinte: | ||
+ | # No ''pc2'' deixe o ping em execução (''ping 10.0.0.1'') | ||
+ | # No ''pc1'' execute o utilitário ''wpa_cli''. Esse programa permite controlar o ''supplicant'', que vem a ser o programa responsável por realizar a autenticação com IEEE 8021x. Ao iniciar o ''wpa_cli'' mostra um prompt (''>''), onde se podem executar comandos de consulta ou modificacão do ''supplicant''. | ||
+ | ## Execute ''status'', e veja as informações sobre a autenticação mantidas pelo ''supplicant''. | ||
+ | ## Execute ''logoff'', e em seguida observe como estão as resposta do ping no ''pc2''. As respostas devem etr parado ... | ||
+ | ## Execute ''logon'', e novamente observe o ping no ''pc2''. Após alguns segundos as respostas devem voltar a ser recebidas. | ||
+ | |||
+ | ===== Definindo um IP de gerenciamento ===== | ||
+ | |||
+ | Um switch pode possuir um endereço IP para fins de gerenciamento. No momento, isso é usado somente para que um switch consiga rodar um servidor Radius e atender pedidos de acesso vindos de outros switches. O IP de gerenciamento precisa estar vinculado a uma das VLANs do switch: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw[management_ip]=192.168.0.10/24:vlan=5 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | No exemplo acima, o switch ''sw'' possui o IP de gerenciamento 192.168.0.10, que está vinculado a VLAN 5. Apenas um IP por switch hpode ser definido. | ||
+ | |||
+ | Como o tipo ''switch'' especializa o tipo ''generic'', é possível definir rotas em um switch que possui um IP de gerenciamento. Isso pode ser feito da mesma forma que em máquinas virtuais genéricas (i.e. usando os atributos [[Netkit#Rotas_est.C3.A1ticas|''default_gateway'' ou ''route'']]). | ||
+ | |||
+ | ===== Usando um servidor Radius ===== | ||
+ | |||
+ | Em uma infraestrutura de controle de acesso IEEE 8021.X, usualmente o servidor de autenticação reside em um equipamento em separado. Desta forma, os autenticadores (switches e ''access points'') podem efetuar a autenticação usando uma base de usuários comum. Apesar do padrão IEEE 8021.X não definir como deve ser implementado o servidor de autenticação, os fabricantes de equipamentos adotaram o serviço Radius para assumir esse papel. Com isso, para implantar o servidor de autenticação deve-se instalar um servidor Radius em algum equipamento, e fazer com que os autenticadores o utilizem para para autenticar os acessos. | ||
+ | |||
+ | No Netkit a implantação de um servidor Radius foi simplificada e integrada à configuração do controle de acesso descrita no [[Netkit#Controle_de_acesso_IEEE_802.1x|início desta seção]]. Por questão de simplicidade, o servidor Radius deve ser implantado em um switch. assim, a configuração de um switch que deve operar como servidor Radius é: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw2[8021x]=1:users=u1/p1,u2/p2:radius_clients=10.0.0.10,10.0.0.254 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | O parâmetro ''users'' lista os usuários e senhas autenticados pelo Radius, e ''radius_clients'' lista os endereços IP dos clientes Radius (que são os demais switches). Em ambos os casos, as informações devem ser escritas como listas separadas por vírgulas. | ||
+ | |||
+ | Os clientes Radius precisam definir que servidor Radius irão utilizar. A configuração de um switch que é cliente Radius poderia ser esta: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw[8021x]=1:radius_server=10.0.0.5 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Note que os clientes Radius devem ser capazes de alcançarem o servidor Radius. Quer dizer, se clientes e servidor Radius estiverem em subredes IP diferentes, devem existir rotas para que eles possam se comunicar. | ||
+ | |||
+ | Um exemplo de uma rede com dois switches, sendo um deles um servidor Radius, está mostrada a seguir: | ||
+ | |||
+ | {| border="0" cellpadding="2" | ||
+ | |- | ||
+ | |<syntaxhighlight lang=text> | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | sw[type]=switch | ||
+ | sw2[type]=switch | ||
+ | |||
+ | sw[8021x]=1:radius_server=10.0.0.5 | ||
+ | sw2[8021x]=1:users=aluno/teste:radius_clients=10.0.0.10 | ||
+ | |||
+ | sw[management_ip]=10.0.0.10/24:vlan=1 | ||
+ | sw2[management_ip]=10.0.0.5/24:vlan=1 | ||
+ | |||
+ | pc1[eth0]=sw-port0:ip=10.0.0.1/24:8021x_user=aluno\teste | ||
+ | pc2[eth0]=sw-port1:ip=10.0.0.2/24:8021x_user=aluno\teste | ||
+ | sw[eth0]=sw-port0:8021x_authenticator=1 | ||
+ | sw[eth1]=sw-port1:8021x_authenticator=1 | ||
+ | sw[eth2]=sw-port2 | ||
+ | |||
+ | sw2[eth0]=sw-port2 | ||
+ | </syntaxhighlight>||[[imagem:Ex-radius.png]] | ||
+ | |} | ||
+ | |||
+ | ===== Usando múltiplas VLANs ===== | ||
+ | |||
+ | * '''isto ainda não funciona ...''' | ||
+ | |||
+ | Quando um switch que é autenticador IEEE 802.1x possui múltiplas VLANs, | ||
+ | |||
+ | ===== Usando freeradius ===== | ||
+ | |||
+ | ==== Agregação de enlace (bonding) ==== | ||
+ | |||
+ | O Linux possui suporte a agregação de enlaces, em que se agrupam interfaces ethernet de forma a parecerem uma única interface (chamado de [http://www.linuxhorizon.ro/bonding.html Linux Channel Bonding]). A interface agregada tem prefixo ''bond'', e assim deve ser identificada como ''bond0'', ''bond1'' e assim por diante. Para criar um enlace agregado no Netkit basta declarar em um switch uma interface desse tipo. A sintaxe da declaração é praticamente idêntica a de interfaces ethernet, como se pode ver abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | sw1[type]=switch | ||
+ | sw2[type]=switch | ||
+ | |||
+ | pc1[eth0]=sw1-port0:ip=192.168.0.1/24 | ||
+ | pc2[eth0]=sw2-port0:ip=192.168.0.2/24 | ||
+ | |||
+ | sw1[eth0]=sw1-port0 | ||
+ | sw2[eth0]=sw2-port0 | ||
+ | |||
+ | # Define em cada switch uma interface bond0 que agrega dois enlaces. | ||
+ | # O enlace agregado deve ser composto por uma ou mais interfaces ethernet. | ||
+ | # O nome do enlace agregado é sw1-sw2 no exemplo. | ||
+ | |||
+ | sw1[bond0]=sw1-sw2:interfaces=eth1,eth2:mode=8023ad | ||
+ | sw2[bond0]=sw1-sw2:interfaces=eth1,eth2:mode=8023ad | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Nesse exemplo o enlace agregado foi criado entre os switches ''sw1'' e ''sw2''. Como se pode notar, existe uma opção de configuração adicional ''interfaces'', usada para listar as interfaces ethernet a serem agrupadas. Essas interfaces não devem ser declaradas explicitamente. Além disso, não se podem configurar VLANs na interface agregada (''bond0'' no exemplo). Por fim, mais de um enlace agregado pode ser criado no mesmo switch, bastando identificá-los por interfaces ''bond'' diferentes (''bond1'', ''bond2'', ...). | ||
+ | |||
+ | O exemplo acima cria a seguinte rede: | ||
+ | |||
+ | [[imagem:Bond.png]] | ||
+ | |||
+ | |||
+ | A definição de interfaces ''bonding'' possui os seguintes atributos: | ||
+ | |||
+ | {| border=1 | ||
+ | !Atributo | ||
+ | !Possíveis valores | ||
+ | !Descrição | ||
+ | |- | ||
+ | |mode || round-robin, backup, xor, 8023ad, tlb, alb|| o tipo de escalonamento de quadros entre as interfaces físicas (default: round-robin) | ||
+ | |- | ||
+ | |interfaces || lista de nomes de interfaces ethernet || as interfaces físicas agregadas | ||
+ | |- | ||
+ | |miimon || um número inteiro || intervalo de monitoramento (em milissegundos) do estado do enlace de cada interface física (default: 100) | ||
+ | |- | ||
+ | |lacp_rate || {slow, fast} || taxa de envio de quadros LACP (slow: a cada 30s, fast: a cada 1s). Default = slow | ||
+ | |} | ||
+ | |||
+ | === Máquinas com suporte a PPPoE === | ||
+ | |||
+ | A configuração de uma infraestrutura de acesso baseada em [[IER-2011-1#PPPoE_.28PPP_over_Ethernet.29|PPPoE]] implica o ajuste de vários detalhes tanto nos clientes quanto no AC (servidor PPPoE). Muitos desses detalhes podem ser abreviados explorando-se opções existentes no Netkit. | ||
+ | |||
+ | Na configuração do Netkit um AC PPPoE deve ser uma máquina virtual do tipo ''pppoe'', que é uma extensão do tipo ''gateway''. Desta forma, todas as capacidades apresentadas por ''gateway'' estão presentes no tipo ''pppoe''. Já as opções necessárias para o funcionamento de um AC devem ser especificadas usando-se o atributo ''pppoe''. O cliente PPPoE, por sua vez, precisa apenas indicar em que interface ethernet será iniciado o enlace PPPoE. O exemplo abaixo mostra uma pequena rede com um AC e dois clientes: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw1[type]=switch | ||
+ | sw2[type]=switch | ||
+ | ac[type]=pppoe | ||
+ | cliente1[type]=generic | ||
+ | cliente2[type]=generic | ||
+ | servidor[type]=generic | ||
+ | |||
+ | # define as opções do AC PPPoE | ||
+ | ac[pppoe]=nome_ac:interface=eth0:users=aluno1/blabla,aluno2/rruahhh:range=172.18.1.1,172.18.1.10:ip=172.18.1.20 | ||
+ | |||
+ | sw1[eth0]=sw1-port0 | ||
+ | sw1[eth1]=sw1-port1 | ||
+ | sw1[eth2]=sw1-port2 | ||
+ | |||
+ | sw2[eth0]=sw2-port0 | ||
+ | sw2[eth1]=sw2-port1 | ||
+ | |||
+ | ac[eth0]=sw1-port0 | ||
+ | ac[eth1]=sw2-port0:ip=192.168.0.1/24 | ||
+ | |||
+ | servidor[eth0]=sw2-port1:ip=192.168.0.10/24 | ||
+ | |||
+ | # Define que a interface eth0 de cliente1 e cliente2 devem operar em modo PPPoE. | ||
+ | cliente1[eth0]=sw1-port1 | ||
+ | cliente1[ppp0]=nome_ac:type=pppoe:user=aluno1:password=blabla:interface=eth0 | ||
+ | |||
+ | cliente2[eth0]=sw1-port2 | ||
+ | cliente2[ppp0]=nome_ac:type=pppoe:user=aluno2:password=rrruahh:interface=eth0 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A configuração acima gera uma rede com dois computadores clientes, um AC PPPoE e um servidor, como mostrado na seguinte figura: | ||
+ | |||
+ | [[imagem:Netkit-pppoe.png]] | ||
+ | |||
+ | |||
+ | A definição do AC PPPoE precisa de algumas opções específicas do PPPoE. Elas devem ser listadas no atributo ''pppoe'' da máquina virtual que representa o AC: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # define as opções do AC PPPoE | ||
+ | ac[pppoe]=nome_ac:interface=eth0:users=aluno1/blabla,aluno2/rruahhh:range=172.18.1.1,172.18.1.10:ip=172.18.1.20 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A primeira opção mostrada acima (''nome_ac'') corresponde ao nome do AC, usado durante a etapa de descoberta PPPoE feita pelos clientes. As demais opções do AC são: | ||
+ | * '''interface:''' a interface ethernet onde o AC vai esperar por pedidos de estabelecimento de enlace PPPoE. | ||
+ | * '''range:''' a faixa de endereços IP a serem concedidos aos clientes. | ||
+ | * '''ip:'''o endereço IP a ser usado pelo AC na sua ponta dos enlaces PPPoE. | ||
+ | * '''users:''' a lista de usuários e respectivas senhas, usados para autenticar os acessos vindos dos clientes. | ||
+ | |||
+ | Um cliente precisa definir uma interface PPP que deve operar em modo PPPoE, informando sobre qual interface ethernet ela deve operar. Além disso, devem ser especificadas as opções PPPoE, como destacado abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # A interface eth0 deve existir para que possa criar a interface ppp0 | ||
+ | cliente1[eth0]=sw1-port1 | ||
+ | |||
+ | # Aqui se declara a interface ppp0 em modo PPPoE | ||
+ | cliente1[ppp0]=nome_ac:type=pppoe:user=aluno1:password=blabla:interface=eth0 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | As opções PPPoE do cliente são: | ||
+ | *'''user:''' o nome de usuário para fins de autenticação PPP. | ||
+ | *'''password:''' a senha do usuário para fins de autenticação PPP. | ||
+ | *'''ac:''' o nome do AC com que se deseja estabelecer o enlace. | ||
+ | |||
+ | Uma vez estabelecido um enlace PPPoE, é criada automaticamente uma rota default no cliente usando o AC como gateway. | ||
+ | |||
+ | === Roteadores === | ||
+ | |||
+ | Roteadores podem ser criados no Netkit usando máquinas virtuais do tipo ''router''. Um roteador tem sua função de gateway ativada automaticamente, e executa o programa [http://www.quagga.net/ Quagga], que implementa protocolos de roteamento (tais como OSPF, RIP e BGP). O exemplo abaixo mostra a criação de uma pequena rede com dois roteadores interligados por um link PPP. | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | r1[type]=router | ||
+ | r2[type]=router | ||
+ | pc1[type]=generic | ||
+ | pc2[type]=generic | ||
+ | |||
+ | r1[ppp0]=link0:ip=10.0.0.1/30 | ||
+ | r1[eth0]=lan0:ip=192.168.0.254/24 | ||
+ | r1[route]=default:dev=ppp0 | ||
+ | |||
+ | r2[ppp0]=link0:ip=10.0.0.2/30 | ||
+ | r2[eth0]=lan1:ip=192.168.1.254/24 | ||
+ | r2[route]=default:dev=ppp0 | ||
+ | |||
+ | pc1[eth0]=lan0:ip=192.168.0.1/24 | ||
+ | pc1[default_gateway]=192.168.0.254 | ||
+ | |||
+ | pc2[eth0]=lan1:ip=192.168.1.2/24 | ||
+ | pc2[default_gateway]=192.168.1.254 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | [[imagem:Exp-routers.png]] | ||
+ | |||
+ | |||
+ | Ao iniciar, um roteador apresenta um ''shell'' parecido com o de um roteador Cisco real, como pode ser visto nas duas telas abaixo. | ||
+ | |||
+ | |||
+ | [[imagem:Netkit-router1.png|borda]] [[imagem:Netkit-router2.png|borda]] | ||
+ | |||
+ | |||
+ | Esse ''shell'' provê somente os comandos de configuração do Quagga. Para executar programas da máquina virtual Linux deve-se usar o comando ''start-shell''. Isso abre um shell usual (''bash''), onde se podem executar programas do Linux. | ||
+ | |||
+ | ==== Ativação de protocolos de roteamento ==== | ||
+ | |||
+ | A ativação de protocolos de roteamento pode ser feita automaticamente no arquivo de configuração. As configurações de cada protocolo de roteamento residem em arquivos contidos no subdiretório ''/etc/quagga'', os quais estão inicialmente vazios. Após iniciar a rede virtual pode-se usar o console do roteador para configurá-lo, e então executar o comando ''write memory'' para gravar sua configuração. Recomenda-se definir o atributo ''preserve'' na máquinas virtuais do tipo roteador, de forma a preservar as configurações desses protocolos (lembre de usar o menu ''File -> Export'' APÓS encerrar a execução da rede virtual, [[Netkit2#Arquivos_de_projeto_do_Netkit:_preservando_modifica.C3.A7.C3.B5es_feitas_nas_m.C3.A1quinas_virtuais|como já explicado]]). | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # Ativa os protocolos RIP e OSPF no roteador r1 | ||
+ | r1[router]=rip,ospf | ||
+ | |||
+ | # Preserva as configurações do roteador r1 | ||
+ | r1[preserve]=/etc/quagga | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Os protocolos de roteamento que podem ser ativados são: | ||
+ | |||
+ | {| border=1 | ||
+ | !Protocolo | ||
+ | !Parâmetro | ||
+ | |- | ||
+ | | RIP || rip | ||
+ | |- | ||
+ | | OSPF|| ospf | ||
+ | |- | ||
+ | | RIPNG || ripng | ||
+ | |- | ||
+ | | OSPF6 || ospf6 | ||
+ | |- | ||
+ | | BGP || bgp | ||
+ | |- | ||
+ | | ISIS || bgp | ||
+ | |} | ||
+ | |||
+ | === Switches MPLS === | ||
+ | |||
+ | [[RCO2-2011-1#MPLS:_Multi_Protocol_Label_Switching|MPLS]] é uma tecnologia para redes WAN que usa o conceito de circuitos virtuais (chamados no MPLS de LSP - ''Label Switched Path''). Existe um projeto no Linux para implementar parte da funcionalidade MPLS, o qual está disponível nas máquinas virtuais do Netkit. Apesar desse projeto estar incompleto, algumas funcionalidades básicas podem ser experimentadas, tais como criação de LSP estáticos e túneis MPLS. No entanto, ainda não é possível criar VPNs MPLS (chamadas de VPLS) ou estabelecer LSP dinâmicos. Assim, no Netkit podem-se criar experimentos explorando essas funções elementares do MPLS. | ||
+ | |||
+ | Um equipamento que comuta rótulos, ou ''switch MPLS'', pode ser criado usando uma máquina virtual do tipo ''mpls''. Em cada switch MPLS devem-se configurar: | ||
+ | * '''FEC:''' classes de equivalência de tráfego, que classificam PDUs não-MPLS que entram na rede MPLS. Essa classificação será usada para definir posteriormente (via NHLFE) que rótulo deve ser adicionado. | ||
+ | * '''NHLFE:''' definem o que deve ser feito com uma PDU (usualmente que rótulo adicionar e por que interface transmiti-la). | ||
+ | * '''Labelspace:''' especificam conjuntos de interfaces por onde se recebem PDUs MPLS. | ||
+ | * '''ILM''': define que rótulos são aceitos vindos de cada labelspace. | ||
+ | |||
+ | Assim, um ''switch MPLS'' precisa usualmente ter configuradas essas quatro informações. A configuração do Netkit mostrada abaixo cria umapequena rede com dois switches MPLS e dois computadores comuns. | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw1[type]=mpls | ||
+ | sw2[type]=mpls | ||
+ | h1[type]=generic | ||
+ | h2[type]=generic | ||
+ | |||
+ | # FEC: mapeia subrede destino para nhlfe | ||
+ | sw1[fec]=192.168.1.0/24:nhlfe=1 | ||
+ | sw2[fec]=192.168.0.0/24:nhlfe=1 | ||
+ | |||
+ | # NHLFE: como encaminhar uma PDU MPLS | ||
+ | sw1[nhlfe]=1:interface=eth0:label=100:ip=10.0.0.2 | ||
+ | sw2[nhlfe]=1:interface=eth0:label=200:ip=10.0.0.1 | ||
+ | |||
+ | # ILM: como identificar PDUs MPLS recebidas | ||
+ | sw1[ilm]=200:labelspace=0 | ||
+ | sw2[ilm]=100:labelspace=0 | ||
+ | |||
+ | # Labelspace: os mapeamentos de labelspaces a interfaces | ||
+ | sw1[labelspace]=0:interfaces=eth0 | ||
+ | sw2[labelspace]=0:interfaces=eth0 | ||
+ | |||
+ | sw1[eth1]=lan0:ip=192.168.0.254/24 | ||
+ | sw1[eth0]=link1:ip=10.0.0.1/24 | ||
+ | sw2[eth0]=link1:ip=10.0.0.2/24 | ||
+ | sw2[eth1]=lan1:ip=192.168.1.254/24 | ||
+ | |||
+ | h1[eth0]=lan0:ip=192.168.0.1/24 | ||
+ | h2[eth0]=lan1:ip=192.168.1.1/24 | ||
+ | |||
+ | h1[default_gateway]=192.168.0.254 | ||
+ | h2[default_gateway]=192.168.1.254 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | [[imagem:Mpls1.png]] | ||
+ | |||
+ | Para configurar cada ítem do ''switch MPLS'' devem-se usar alguns atributos: | ||
+ | * '''FEC:''' usa-se o atributo ''fec'' <syntaxhighlight lang=text> | ||
+ | sw1[fec]=192.168.1.0/24:nhlfe=1 | ||
+ | </syntaxhighlight>Esse atributo possui apenas duas opções: | ||
+ | ** ''IP/Máscara'': a rede destino (''192.168.1.0/24'' no exemplo) | ||
+ | ** ''nhfe=um_número'': o número do NHLFE a ser usado (''nhlfe=1'' no exemplo)<br> | ||
+ | * '''NHLFE:''' usa-se o atributo ''nhlfe'' <syntaxhighlight lang=text> | ||
+ | sw1[nhlfe]=1:interface=eth0:label=100:ip=10.0.0.2 | ||
+ | </syntaxhighlight>As seguintes opções existem: | ||
+ | ** ''um_número'': o número do NHLFE. Funciona como um identificador a ser usado no ILM ou FEC. | ||
+ | ** ''label=um_número'': o número de rótulo a ser adicionado. | ||
+ | ** ''interface=nome_interface'': a interface por onde será transmitido o pacote MPLS. | ||
+ | ** ''ip=um_IP'': endereço IP do próximo switch MPLS (o que deve receber as PDUs transmitidas de acordo com esta NHLFE)<br><br>Além dessa opções pode-se especificar um NHLFE de forma a empilhar rótulos (adicionar dois ou mais rótulos a uma mesma PDU), o que é necessário na entrada de túneis MPLS:<syntaxhighlight lang=text> | ||
+ | sw1[nhlfe]=1:label=200:nhlfe=2 | ||
+ | </syntaxhighlight>Nesse caso não se usam as opções ''ip'' e ''interface'', porém adiciona-se a seguinte opção: | ||
+ | ** ''nhlfe=um_número'': identificador da NHLFE a ser usada depois da aplicação desta NHLFE.<br> | ||
+ | * '''ILM:''' usa-se o atributo ''ilm'' <syntaxhighlight lang=text> | ||
+ | sw1[ilm]=1000:labelspace=0:nhlfe=2 | ||
+ | </syntaxhighlight>As opções que podem ser usadas são: | ||
+ | ** ''um_número'': o número do rótulo que será reconhecido. | ||
+ | ** ''labelspace=um_número'': o número do labelspace de onde se aceitará o rótulo. | ||
+ | ** ''nhlfe=um_número'': o identificador do NHLFE a ser usado para encaminhar essas PDUs MPLS.<br><br>Uma forma alternativa de definir o ''ilm'' omite a opção ''nhlfe''. Nesse caso a PDU MPLS será aceita, o rótulo será removido e a PDU será então processada normalmente pela camada de rede IP.<br> | ||
+ | * '''Labelspaces:''' usa-se o atributo ''labelspace''<syntaxhighlight lang=text> | ||
+ | sw1[labelspace]=0:interfaces=eth0,eth1 | ||
+ | </syntaxhighlight>Suas opções são apenas: | ||
+ | ** ''um_número'': o número do labelspace ('''OBS:''' na versão do MPLS usada, existe somente ''labelspace'' global ... portanto o número do ''labelspace'' é ignorado). | ||
+ | ** ''interfaces=if1,if2,...'': a lista de uma ou mais interfaces que pertencem a esse labelspace. | ||
+ | |||
+ | Qualquer um desses atributos pode ser especificado múltiplas vezes, como exemplificado abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw1[nhlfe]=1:interface=eth0:label=100:ip=192.168.0.2 | ||
+ | sw1[nhlfe]=2:label=1000:nhlfe=1 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | A configuração acima irá adicionar duas NHLFE em ''sw1''. | ||
+ | |||
+ | Um exemplo de uma rede um pouco maior contém três switches MPLS: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | sw1[type]=mpls | ||
+ | sw2[type]=mpls | ||
+ | sw3[type]=mpls | ||
+ | h1[type]=generic | ||
+ | h2[type]=generic | ||
+ | h3[type]=generic | ||
+ | |||
+ | # FEC: mapeia subrede/mask para nhlfe | ||
+ | sw1[fec]=192.168.1.0/24:nhlfe=1 | ||
+ | sw1[fec]=192.168.2.0/24:nhlfe=2 | ||
+ | sw2[fec]=192.168.0.0/24:nhlfe=1 | ||
+ | sw2[fec]=192.168.2.0/24:nhlfe=2 | ||
+ | sw3[fec]=192.168.0.0/24:nhlfe=1 | ||
+ | sw3[fec]=192.168.1.0/24:nhlfe=2 | ||
+ | |||
+ | # NHLFE: como encaminhar uma PDU MPLS ... (push) | ||
+ | sw1[nhlfe]=1:interface=eth0:label=110:ip=10.0.0.2 | ||
+ | sw1[nhlfe]=2:interface=eth0:label=120:ip=10.0.0.2 | ||
+ | sw2[nhlfe]=1:interface=eth0:label=210:ip=10.0.0.1 | ||
+ | sw2[nhlfe]=2:interface=eth1:label=220:ip=10.0.2.3 | ||
+ | sw2[nhlfe]=3:interface=eth1:label=130:ip=10.0.2.3 | ||
+ | sw3[nhlfe]=1:interface=eth0:label=310:ip=10.0.1.1 | ||
+ | sw3[nhlfe]=2:interface=eth1:label=320:ip=10.0.2.2 | ||
+ | |||
+ | # ILM: como identificar PDUs MPLS recebidas (implicitamente faz um pop) | ||
+ | sw1[ilm]=210:labelspace=0 | ||
+ | sw1[ilm]=310:labelspace=0 | ||
+ | sw2[ilm]=110:labelspace=0 | ||
+ | sw2[ilm]=120:labelspace=0:nhlfe=3 | ||
+ | sw2[ilm]=320:labelspace=0 | ||
+ | sw3[ilm]=130:labelspace=0 | ||
+ | sw3[ilm]=220:labelspace=0 | ||
+ | |||
+ | # Labelspace: os mapeamentos de labelspaces a interfaces | ||
+ | sw1[labelspace]=0:interfaces=eth0,eth1 | ||
+ | sw2[labelspace]=0:interfaces=eth0,eth1 | ||
+ | sw3[labelspace]=0:interfaces=eth0,eth1 | ||
+ | |||
+ | sw1[eth0]=link1:ip=10.0.0.1/24 | ||
+ | sw1[eth1]=link2:ip=10.0.1.1/24 | ||
+ | sw1[eth2]=lan0:ip=192.168.0.254/24 | ||
+ | |||
+ | sw2[eth0]=link1:ip=10.0.0.2/24 | ||
+ | sw2[eth1]=link3:ip=10.0.2.2/24 | ||
+ | sw2[eth2]=lan1:ip=192.168.1.254/24 | ||
+ | |||
+ | sw3[eth0]=link2:ip=10.0.1.3/24 | ||
+ | sw3[eth1]=link3:ip=10.0.2.3/24 | ||
+ | sw3[eth2]=lan2:ip=192.168.2.254/24 | ||
+ | |||
+ | h1[eth0]=lan0:ip=192.168.0.1/24 | ||
+ | h2[eth0]=lan1:ip=192.168.1.1/24 | ||
+ | h3[eth0]=lan2:ip=192.168.2.1/24 | ||
+ | |||
+ | h1[default_gateway]=192.168.0.254 | ||
+ | h2[default_gateway]=192.168.1.254 | ||
+ | h3[default_gateway]=192.168.2.254 | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | [[imagem:Mpls2.png]] | ||
+ | |||
+ | == Opções e configurações avançadas == | ||
+ | |||
+ | === Preferências === | ||
+ | |||
+ | Atributos globais definem parâmetros válidos para o experimento como um todo. Esses atributos devem ser especificados com a sintaxe ''global[nome_do_atributo]=valor_do_atributo''. No momento há apenas o atributo '''path''', que define o diretório onde devem ser criados os arquivos temporários e discos virtuais do experimento. O diretório de trabalho pode ser especificado com um caminho relativo, como exemplificado abaixo: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # o diretório de trabalho do experimento será o subdiretório "tmp" dentro do diretório onde | ||
+ | # está o arquivo de configuração (i.e. diretorio_do_arquivo_de_configuracao/tmp) | ||
+ | global[path]=tmp | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ... ou um caminho absoluto: | ||
+ | |||
+ | <syntaxhighlight lang=text> | ||
+ | # o diretório de trabalho do experimento será o subdiretório "/home/aluno/tmp". | ||
+ | global[path]=/home/aluno/tmp | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Se o atributo global ''path'' não for definido, o '''netkit2''' irá criar um subdiretório dentro do diretório onde está o arquivo de configuração, e usá-lo como diretório de trabalho. O nome desse subdiretório será da forma ''tmp-xxxxx'', sendo ''xxxxx'' um número aleatório. | ||
+ | |||
+ | === Projetos === | ||
+ | |||
+ | === Modo de instalação de software === | ||
+ | |||
+ | == Uma biblioteca de exemplos de experimentos == | ||
+ | |||
+ | Para facilitar o aprendizado de como usar o Netkit foi criada uma pequena coleção de experimentos. | ||
+ | |||
+ | === Experimentos com LANs === | ||
+ | |||
+ | * [http://tele.sj.ifsc.edu.br/~msobral/RCO2/netkit/lan.tgz LAN simples]: uma LAN com quatro computadores (pc1, pc2, pc3, pc4). Os computadores virtuais têm IPs 192.168.1.X, sendo X o número computador (ex: pc1 tem IP 192.168.1.1). Use ping para fazer testes de comunicação. Veja o arquivo ''Lab.conf'' (configuração da rede) e ''pc1.startup'', ''pc2.startup'', ''pc3.startup'' e ''pc4.startup'' (scripts que configuram cada máquina virtual após o boot). A rede criada nesse experimento está mostrada abaixo: | ||
+ | |||
+ | [[imagem:Exemplo-Lan1-netkit.png]] | ||
+ | |||
+ | |||
+ | Ao executar esse experimento quatro terminais surgirão (um para cada máquina virtual). A figura abaixo mostra o experimento em execução, e nele a máquina virtual ''pc'' fazendo um ping em broadcast e em ''pc2'' e ''pc3'' sendo executado ''tcpdump'' para ver as mensagens ICMP geradas pelo ping: | ||
+ | |||
+ | [[imagem:Ier-lan1-netkit.png|600px]] | ||
+ | |||
+ | |||
+ | * [http://tele.sj.ifsc.edu.br/~msobral/RCO2/netkit/lan-ppp.tgz Duas LANs interligadas com PPP]: uma LAN com quatro computadores (pc1, pc2, pc3, pc4) ligada com PPP a outra LAN (pc5, pc6 e pc7). O link PPP é implantado sobre as portas seriais das máquinas virtuais pc4 e pc5. Ver os arquivos ''Lab.conf'', ''pc4.startup'' e ''pc5.startup''. A rede do experimento está mostrada abaixo: | ||
+ | |||
+ | [[imagem:Lan-ppp.png]] | ||
+ | |||
+ | |||
+ | * [http://tele.sj.ifsc.edu.br/~msobral/RCO2/netkit/bridge.tgz LAN com switch]: uma LAN com quatro computadores (pc1, pc2, pc3, pc4) interligados por um switch. O switch é implementado por um computador com Linux com 4 portas ethernet. Ver os arquivos ''Lab.conf'' e ''switch.startup''. A rede do experimento está mostrada abaixo: | ||
+ | |||
+ | [[imagem:Exemplo-Bridge-netkit.png]] | ||
+ | |||
+ | |||
+ | * [http://tele.sj.ifsc.edu.br/~msobral/RCO2/netkit/lan2.tgz LAN com dois switches]: uma LAN com 6 computadores (pc1 a pc6) interligados por dois switches (switch1 e switch2). Ambos switches são implementados por computadores com Linux com 4 portas ethernet. Ver os arquivos ''Lab.conf'', ''switch1.startup'' e ''switch2.startup''. A rede do experimento está mostrada abaixo: | ||
+ | |||
+ | [[imagem:Exemplo-lan2.png]] | ||
+ | |||
+ | === Experimentos com VLAN === | ||
+ | |||
+ | Observar os quadros com ''tag'' nas interfaces que operam em modo ''tagged''. Teste também o isolamento entre VLANs. | ||
+ | |||
+ | * [http://tele.sj.ifsc.edu.br/~msobral/RCO2/netkit/bridge2.tgz Switch e duas VLANs]: duas VLANs com quatro computadores cada. VLAN 5 tem IPs 192.168.1.0/24 e contém pc1, pc2, pc3, pc4; VLAN 10 tem IPs 192.168.2.0/24 e contém pc4, pc5, pc6, pc7. O switch Linux foi configurado para que a interface eth3 esteja nas VLANs 5 e 10 (i.e. em modo ''tagged''), as interfaces eth0, eth1, eth2 estejam na VLAN 5 em modo ''untagged'', e as interfaces eth4, eth5 e eth6 estejam na VLAN 10 em modo ''untagged''. O computador pc4 opera como gateway entre as VLANs, usando duas interfaces virtuais (i.e. a interface eth0 foi posta nas VLANs 5 e 10 em modo ''tagged''). Nesse exemplo se usa ''VLAN tagging'' IEEE 802.1q. | ||
+ | |||
+ | [[imagem:Bridge2.png]] | ||
+ | |||
+ | |||
+ | * [http://tele.sj.ifsc.edu.br/~msobral/RCO2/netkit/bridge3.tgz Dois switches e duas VLANs]: duas VLANs com quatro computadores cada. VLAN 5 tem IPs 192.168.1.0/24 e contém pc1, pc2, pc3, pc4; VLAN 10 tem IPs 192.168.2.0/24 e contém pc5, pc6, pc7, pc8. O switch Linux foi configurado para que a interface eth3 esteja nas VLANs 5 e 10 (i.e. em modo ''tagged''), as interfaces eth0, eth1, eth2 estejam na VLAN 5 em modo ''untagged'', e as interfaces eth4, eth5 e eth6 estejam na VLAN 10 em modo ''untagged''. O computador pc4 opera como gateway entre as VLANs, usando duas interfaces virtuais (i.e. a interface eth0 foi posta nas VLANs 5 e 10 em modo ''tagged''). Nesse exemplo se usa ''VLAN tagging'' IEEE 802.1q. O diagrama abaixo ilustra essa rede: | ||
+ | |||
+ | [[imagem:Bridge3.png]] | ||
+ | |||
+ | Leia os arquivos de inicialização ''switch1.startup'', ''switch2.startup'' e ''pc4.startup'' para entender como foram configuradas as VLANs. | ||
+ | |||
+ | = API do Netkit = | ||
+ | |||
+ | O Netkit possui uma API para iniciar e parar experimentos, entre outras coisas. Ela está implementada no módulo ${NETKIT2_HOME}/bin/netkit.py, mas não deve ser usada diretamente. Para usá-la é recomendável usar NetkitParser, uma classe que interpreta arquivos de configuração e a partir deles cria objetos Network. A classe Network representa uma rede virtual do Netkit, e com ela se pode inciar, parar, ou mudar preferências. O exemplo abaixo mostra como usar a classe NetkitParser e o objeto Network obtido por meio dela: | ||
+ | |||
+ | <syntaxhighlight lang=python> | ||
+ | import nkparser | ||
+ | |||
+ | # Cria o parser, informando o arquivo de configuração a ser interpretado | ||
+ | parser = nkparser.NetkitParser('teste.conf') | ||
+ | |||
+ | # Interpreta o arquivo de configuração | ||
+ | parser.parse() | ||
+ | |||
+ | # Obtém um objeto Network que representa a rede descrita no arquivo de configuração | ||
+ | rede = parser.get_network() | ||
+ | |||
+ | # Executa a rede. Cada VM terá sua console vinculada a um xterm | ||
+ | rede.start() | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | As classes envolvidas na API do Netkit estão representadas no diagrama de classes abaixo. Existem muitas outras classes no Netkit, mas estas são suficientes para utilizá-lo: | ||
+ | |||
+ | |||
+ | [[imagem:Netkit-class-diagram1.png]] | ||
+ | |||
+ | |||
+ | Este outro exemplo explora as classes acima apresentadas. Ele inicia uma rede a partir de um arquivo de configuração, porém vincula cada VM a um [[Netkit2#interface_Terminal|Terminal]] (que pode ser um ''xterm'' ou alguma outra forma de interagir com a VM). As classes contidas no diagrama acima, e usadas neste programa, estão descritas nas próximas subseções. | ||
+ | |||
+ | <syntaxhighlight lang=python> | ||
+ | # Cria um experimento Netkit | ||
+ | parser = nkparser.NetkitParser('teste.conf') | ||
+ | |||
+ | parser.parse() | ||
+ | |||
+ | rede = parser.get_network() | ||
+ | |||
+ | # Cria um gerador de terminais | ||
+ | pool = TermPool() | ||
+ | |||
+ | # Inicia o experimento usando o gerador de terminais | ||
+ | rede.start(pool) | ||
+ | |||
+ | # Inicia todos os terminais e, consequentemente, todas as VM do experimento | ||
+ | pool.start() | ||
+ | |||
+ | # Obtém o terminal da VM pc1 | ||
+ | term = pool.get_term('pc1') | ||
+ | |||
+ | # Através do objeto term se pode conversar com a console da VM pc1 ... | ||
+ | term.write('poweroff\n') | ||
+ | |||
+ | </syntaxhighlight> | ||
+ | |||
+ | == Classe '''NetkitParser''' == | ||
+ | |||
+ | ''Definida em nkparser.py'' | ||
+ | |||
+ | |||
+ | [[imagem:NetkitParser.png]] | ||
+ | |||
+ | |||
+ | Um objeto da classe ''NetkitParser'' implementa um ''parser'' (analisador sintático). Com ele se pode interpretar um arquivo de configuração de uma rede, e criar a rede ali descrita. Se houver erros de sintaxe, ou mesmo semânticos, o ''parser'' dispara uma exceção avisando sobre o erro e em que parte do arquivo ele foi encontrado. Se o arquivo de configuração não tiver erros, o ''parser'' cria um objeto [[Netkit2#Classe_Network|Network]] para representar a rede. O ''parser'' pode também ser usado para analisar um arquivo de configuração, sem criar um objeto Network, desta forma apenas verificando a correção da configuração. | ||
+ | |||
+ | <br>constructor: ''NetkitParser(conf_path)'' | ||
+ | {| border="1" | ||
+ | !Parâmetro | ||
+ | !Descrição | ||
+ | |- | ||
+ | |conf_path || caminho para o arquivo de configuração da rede a ser criada | ||
+ | |} | ||
+ | |||
+ | |||
+ | '''Métodos:''' | ||
+ | |||
+ | ''parse()'': interpreta o arquivo de configuração. Erros de sintaxe causam exceções do tipo [[Netkit2#Classe_ParseError|''ParseError'']], e erros semânticos (ex: uso de uma VM não declarada) disparam exceções do tipo [[Netkit2#Classe_SemanticError|''SemanticError'']]. Essas exceções informam sobre a localização do erro dentro do arquivo de configuração. | ||
+ | |||
+ | ''get_network()'': obtém um objeto Network que representa a rede descrita no arquivo de configuração. Esse método somente pode ser chamado após o arquivo ter sido interpretado (i.e. após ''parse()''). | ||
+ | |||
+ | ''update_prefs(prefs)'': modifica as preferências da rede de forma permanente, acrescentando-as ao arquivo de configuração. | ||
+ | |||
+ | ''tokenize()'': faz a análise léxica do arquivo de configuração, retornando uma lista com todos os ''tokens'' encontrados. | ||
+ | |||
+ | === Classe ParseError === | ||
+ | |||
+ | A classe ParseError especializa a classe Exception para representar erros na análise léxica ou sintática de um arquivo de configuração. Uma exceção ParseError possui os seguintes atributos: | ||
+ | |||
+ | * '''n''': o número da linha onde foi identificado o erro. | ||
+ | * '''column''': a coluna onde inicia o texto incorreto. | ||
+ | * '''value''': a palavra ou ''token'' incorreto. | ||
+ | * '''line''': a linha completa onde se encontra o erro. | ||
+ | |||
+ | === Classe SemanticError === | ||
+ | |||
+ | A classe SemanticError especializa a classe Exception para representar erros na análise semântica de um arquivo de configuração. Uma exceção SemanticError possui os seguintes atributos: | ||
+ | |||
+ | * '''n''': o número da linha onde foi identificado o erro. | ||
+ | * '''value''': a causa do erro. | ||
+ | * '''line''': a linha completa onde se encontra o erro. | ||
+ | |||
+ | == Classe '''Network''' == | ||
+ | |||
+ | ''Definida em netkit.py'' | ||
+ | |||
+ | |||
+ | [[imagem:Network.png]] | ||
+ | |||
+ | |||
+ | A classe Network representa redes do Netkit. Um objeto dessa classe contém todas as especificações para a criação e configuração de uma rede. Através dele se pode iniciar e para a execução de uma rede. No entanto, objetos da classe Network devem ser criados por meio de um objeto [[Netkit2#Classe_NetkitParser|NetkitParser]]. | ||
+ | |||
+ | |||
+ | A classe Network possui os seguintes métodos: | ||
+ | * ''start(pool=None)'': inicia uma rede usando o ''pool'' indicado (ver [[Netkit2#interface_TermPool|TermPool]]). Um ''pool'' serve para acoplar [[Netkit2#interface_Terminal|terminais]] às máquinas virtuais da rede. Se o ''pool'' não for especificado, é usado um ''pool'' padrão, que conecta cada máquina virtual a um [http://manpages.ubuntu.com/manpages/karmic/en/man1/xterm.1.html xterm]. | ||
+ | * ''stop()'': para a execução de uma rede. | ||
+ | * ''get_nodes()'': retorna uma lista com os nomes do nodos que fazem parte da rede virtual. | ||
+ | * ''get_prefs()'': retorna um dicionário com as preferências de execução da rede virtual. | ||
+ | * ''update_prefs(prefs)'': modifica as preferências de execução da rede de acordo com o dicionário ''prefs''. | ||
+ | * ''get_pool()'': obtém uma referência ao objeto [Netkit2#interface_TermPool|TermPool]] usado pela rede. | ||
+ | * ''get_path()'': retorna o caminho do diretório (''pathname'') de trabalho da rede virtual. | ||
+ | |||
+ | |||
+ | As preferências são compostas pelos seguintes atributos: | ||
+ | * ''mem'' (inteiro): quantidade de memória (em MB) a ser alocada a cada máquina virtual. | ||
+ | * ''path'' (string): caminho do diretório de trabalho da rede virtual. | ||
+ | * ''rw'' (booleano): ativa o modo leitura-escrita, se ''True''. Nesse modo as modificações no sistema de arquivos das máquinas virtuais são permanentes. Use com cuidado ! | ||
+ | * ''compact'' (booleano): compacta o arquivo de projeto, caso seja utilizado (ver atributo [[Netkit2#Arquivos_de_projeto_do_Netkit:_preservando_modifica.C3.A7.C3.B5es_feitas_nas_m.C3.A1quinas_virtuais|''preserve'']] de uma máquina virtual). | ||
+ | |||
+ | |||
+ | Outros atributos podem ser adicionados às preferências, o que pode ser útil para softwares que utilizem esta API. Por exemplo, ''netkit2'' é um aplicativo gráfico para a execução de redes do Netkit que usa o atributo ''vm'' para especificar quantas máquinas virtuais podem ser executadas em paralelo, e ''clean'' para indicar se o diretório de trabalho da rede deve ser removido após sua execução. | ||
+ | |||
+ | == Classe '''VM''' == | ||
+ | |||
+ | ''Definida em uml_layer.py'' | ||
+ | |||
+ | |||
+ | [[imagem:VM.png]] | ||
+ | |||
+ | |||
+ | A classe VM representa máquinas virtuais UML. Um objeto dessa classe pode iniciar, parar e acessar a console de uma máquina virtual. Objetos dessa classe são criados automaticamente ao se inciar uma rede (i.e. ao se chamar o método ''start()'' de um objeto [[Netkit2#Classe_Network|Network]]). As operações dessa classe são: | ||
+ | * ''start()'': executa uma máquina virtual UML correspondente a um nodo de uma rede virtual. A máquina virtual é executada em um processo filho, e sua console é conectada ao lado escravo de um pseudo-terminal. O descritor de arquivo do lado mestre é retornado como resultado deste método. | ||
+ | * ''startWithin(command)'': executa uma máquina virtual UML usando o comando indicado. Este método serve para usar aplicativos de terminal (ex: xterm, gnome-terminal) como terminais das máquinas virtuais. A linha de comando que inicia a máquina virtual é simplesmente acrescentada logo após o nome do ''comando'' fornecido. | ||
+ | * ''stop()'': termina a execução de uma máquina virtual. | ||
+ | * ''wait()'': aguarda uma máquina virtual terminar sua execução. | ||
+ | * ''getPty()'': obtém o descritor de arquivo (''fd'') do lado mestre do pseudo-terminal conectado a console da máquina virtual. | ||
+ | * ''started()'': retorna ''True'' se a máquina virtual estiver em execução, e ''False'' caso contrário. | ||
+ | * ''get_name()'': retorna o nome da máquina virtual. | ||
+ | |||
+ | == interface TermPool == | ||
+ | |||
+ | ''Definido pelo software que usa a API do Netkit. O TermPool default está em uml_layer.py'' | ||
+ | |||
+ | |||
+ | [[imagem:TermPool.png]] | ||
+ | |||
+ | |||
+ | A interface ''TermPool'' define um concentrador de terminais para as máquinas virtuais. Sua função é criar um terminal para cada VM a ser executada. Esses terminais devem ser objetos que implementam a interface [[Netkit2#interface_Terminal|Terminal]], os quais desempenham esse papel para as VM. Quer dizer, cada objeto Terminal deve se associar à console de uma VM e agir como um terminal de fato. | ||
+ | |||
+ | '''Métodos:''' | ||
+ | |||
+ | *''addVM(vm_object)'': adiciona um Terminal e o associa à VM representada por''vm_object'', que é um objeto da [[Netkit2#Classe_VM|classe VM]]. | ||
+ | *''start()'': inicia todas as VM em seus respectivos terminais. | ||
+ | *''stop()'': para todas as VM. | ||
+ | *''get_terms()'': retorna um dicionário com todos os terminais indexados pelos nomes de suas VM. | ||
+ | *''get_term(nome)'': retorna o terminal da VM ''nome''. | ||
+ | *''get_fds()'': retorna uma lista com os descritores de arquivos do lado mestre dos pseudo-terminais associados às VM. | ||
+ | |||
+ | |||
+ | '''OBS:''' Deve-se implementar uma classe que realize a interface TermPool, a qual é necessária para que se possam executar redes por meio de objetos Network [[Netkit2#Classe_Network|Network]]. | ||
+ | |||
+ | |||
+ | '''Exemplo de classe que realiza ''TermPool'':''' | ||
+ | |||
+ | <syntaxhighlight lang=python> | ||
+ | class TermPool: | ||
+ | |||
+ | def __init__(self): | ||
+ | self.terms = {} | ||
+ | |||
+ | def addVM(self, name, cmd): | ||
+ | self.terms[name] = NetTerm(name, cmd) | ||
+ | |||
+ | def start(self): | ||
+ | for vm in self.terms: | ||
+ | self.terms[vm].start() | ||
+ | |||
+ | def stop(self): | ||
+ | for vm in self.terms: | ||
+ | self.terms[vm].stop() | ||
+ | |||
+ | def get_term(self, name): | ||
+ | return self.terms[name] | ||
+ | |||
+ | def get_terms(self): | ||
+ | return self.terms | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | == interface Terminal == | ||
+ | |||
+ | '''OBS:''' Deve-se implementar uma classe que realize esta interface, a qual é necessária para [[Netkit2#interface_TermPool|TermPool]]. | ||
+ | |||
+ | |||
+ | [[imagem:Terminal.png]] | ||
+ | |||
+ | |||
+ | A interface Terminal define como devem se apresentar objetos as serem usados como ''terminais'' para as VM do Netkit. Um Terminal tem o papel de interfacear o console de uma VM, dependendo da forma com que se deseje acessar a rede em execução. Por exemplo, um Terminal pode simplesmente conectar um [http://manpages.ubuntu.com/manpages/karmic/en/man1/xterm.1.html xterm] ao console da VM, ou fazer algo mais complexo, como vinculá-la a um socket para que possa ser acessada remotamente. Objetos que implementam essa interface não devem ser instanciados diretamente, pois são criados por [[Netkit2#interface_TermPool|TermPool]]. | ||
+ | |||
+ | <br>'''Construtor''': ''Terminal(vm)'' | ||
+ | {| border="1" | ||
+ | !Parâmetro | ||
+ | !Descrição | ||
+ | |- | ||
+ | |vm || uma instância da classe VM, a qual representa a VM a ser interfaceada | ||
+ | |} | ||
+ | |||
+ | |||
+ | '''Métodos:''' | ||
+ | |||
+ | *''start()'': inicia a VM, conectando seu console ao lado escravo de um pseudo-terminal. Esse pseudo-terminal deve ser criado pelo ''Terminal''. | ||
+ | *''stop()'': para a VM. | ||
+ | *''read(maxbytes)'': lê até ''maxbytes'' do console da VM , retornando-os como uma ''string''. | ||
+ | *''write(data)'': escreve os dados contidos na string ''data'' no console da VM. | ||
+ | *''getfd()'': retorna uma referência ao descritor de arquivo do lado mestre do pseudo-terminal vinculado ao console da VM. Pode ser usado para enviar e receber dados diretamente da VM. | ||
+ | |||
+ | |||
+ | '''Exemplo de classe que realiza ''Terminal'':''' | ||
+ | |||
+ | <syntaxhighlight lang=python> | ||
+ | class NetTerm: | ||
+ | |||
+ | def __init__(self, vm): | ||
+ | self.name = vm.get_name() | ||
+ | self.fd = -1 | ||
+ | |||
+ | def start(self): | ||
+ | pass | ||
+ | |||
+ | def stop(self): | ||
+ | pass | ||
+ | |||
+ | </syntaxhighlight> | ||
+ | |||
+ | == API RESTful == | ||
+ | |||
+ | A API [http://en.wikipedia.org/wiki/Restful RESTful] foi concebida como uma interface entre clientes remotos e o Netkit. Essa API deve ser implementada por um controlador de instâncias do Netkit, o qual deve ser capaz de traduzir as operações da API para ações sobre redes virtuais do Netkit. Essa interface ainda está em desenvolvimento, e faz parte do [[Criação_de_uma_infraestrutura_para_execução_remota_do_Netkit | TCC de Ricardo Martins (2013-2 a 2014-1)]]. | ||
+ | |||
+ | |||
+ | Esta tabela lista as operações da API RESTful. | ||
+ | * nas URI que representam os recursos, ''ID'' é o nome de uma rede, e ''NUM'' é o número de uma instância dessa rede. | ||
+ | * parâmetros são enviados no corpo da requisição com tipo [http://en.wikipedia.org/wiki/Application/x-www-form-urlencoded#The_application.2Fx-www-form-urlencoded_type ''application/x-www-form-urlencoded'']. O tipo de cada parâmetro é ''string'', salvo indicado em contrário. | ||
+ | * resultados, quando houver, são codificados em [http://en.wikipedia.org/wiki/JSON JSON] (tipo ''application/json''), salvo quando indicado outro tipo. | ||
+ | |||
+ | |||
+ | {| border="1" | ||
+ | !rowspan="2" style="width: 200px;" |Recurso | ||
+ | !rowspan="2" |Método | ||
+ | !rowspan="2" |Parâmetros | ||
+ | !colspan="3" |Resultado | ||
+ | !rowspan="2" |Descrição da operação | ||
+ | |- | ||
+ | | <center>'''Status'''</center> || <center>'''Corpo da resposta'''</center>||<center>'''Descrição'''</center> | ||
+ | |- | ||
+ | |rowspan="2" | /netkit || rowspan="2" | GET ||rowspan="2" | || 200 || {'''nome_rede''': URI_rede} || ''sucesso'', e retorna redes existentes no corpo da resposta|| rowspan="2" | Obtém a relação de redes existentes no catálogo do controlador | ||
+ | |- | ||
+ | | 400 || || erro de execução | ||
+ | |- | ||
+ | |rowspan="3" | /netkit || rowspan="3" |POST || rowspan="3" |{'''name:''' nome da rede, '''config:''' configuração}|| 201 || || ''sucesso'': URI da rede criada no cabeçalho ''Location'' || rowspan="3" |Cria uma nova rede identificada por ''name'' e com configuração dada por ''config'' | ||
+ | |- | ||
+ | | 409|| || erro: rede já existe | ||
+ | |- | ||
+ | | 400 ||{'''line''': ''linha'', '''column''':''coluna'', '''value''': ''token''} || erro de sintaxe na configuração, e retorna o local do erro no corpo da resposta | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID || rowspan="3" |POST ||rowspan="3" | || 201 ||{'''dataport''': URI_dataport, '''nodes''': lista de nomes de nodos, '''active:''' nome do nodo ativo} || sucesso, com URI da instância no cabecalho ''Location''||rowspan="3" | Inicia a execução de uma rede | ||
+ | |- | ||
+ | | 400|| ||erro genérico | ||
+ | |- | ||
+ | | 404|| ||rede não existe | ||
+ | |- | ||
+ | |rowspan="4" |/netkit/ID || rowspan="4" |DELETE ||rowspan="4" | ||200|| ||sucesso ||rowspan="4" | Remove uma rede do catálogo | ||
+ | |- | ||
+ | | 404|| ||rede não existe | ||
+ | |- | ||
+ | |423|| ||há instâncias em execução | ||
+ | |- | ||
+ | |400|| ||erro genérico | ||
+ | |- | ||
+ | |rowspan="3" | /netkit/ID/config || rowspan="3" |GET ||rowspan="3" | ||200 || configuração da rede (''text/plain'') || sucesso e corpo da mensagem contém a configuração ||rowspan="3" |Obtem a configuração de uma rede | ||
+ | |- | ||
+ | | 404 || || rede não existe | ||
+ | |- | ||
+ | | 400|| || erro genérico | ||
+ | |- | ||
+ | |rowspan="5" |/netkit/ID/config || rowspan="5" |PUT ||rowspan="5" |configuração da rede (text/plain) ||200|| ||''sucesso'' || rowspan="5" |Modifica a configuração de uma rede | ||
+ | |- | ||
+ | | 404 || ||rede não existe | ||
+ | |- | ||
+ | | 400 ||{'''line''': ''linha'', '''column''':''coluna'', '''value''': ''token''} || erro de sintaxe | ||
+ | |- | ||
+ | |406 || || conteúdo não é ''text/plain'' | ||
+ | |- | ||
+ | | 500 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/preferences || rowspan="3" |GET ||rowspan="3" | ||200 ||{'''mem''': memória em MB, '''rw''': modo ''rw''} ||''sucesso'' ||rowspan="3" | Obtém as preferências de execução de uma rede. | ||
+ | |- | ||
+ | |404 || || rede não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" | /netkit/ID/preferences || rowspan="3" |PUT ||rowspan="3" |{'''mem''': memória em MB, '''rw''': modo ''rw''} ||200 || ||''sucesso'' ||rowspan="3" | Modifica as preferências de execução de uma rede. | ||
+ | |- | ||
+ | |404 || || rede não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/image || rowspan="3" |GET ||rowspan="3" | ||200 ||imagem (''image/png'') ||''sucesso''||rowspan="3" | Obtém a imagem de um diagrama da rede. | ||
+ | |- | ||
+ | |404 || || rede não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/dot || rowspan="3" |GET ||rowspan="3" | ||200 ||conteúdo ''dot'' (''text/plain'') ||''sucesso''||rowspan="3" | Obtém a descrição ''.dot'' de um diagrama da rede. | ||
+ | |- | ||
+ | |404 || || rede não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/NUM || rowspan="3" |GET ||rowspan="3" | ||200 ||{'''dataport''': URI_dataport, '''nodes''': lista de nomes de nodos, '''active:''' nome do nodo ativo} ||''sucesso'' ||rowspan="3" |Obtém os atributos de uma instância: dataport, lista de nodos, nodo ativo | ||
+ | |- | ||
+ | |404 || || rede ou instância não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/NUM || rowspan="3" |PUT ||rowspan="3" | {'''active''': nome_do_nodo}||200 ||{'''active''': nome_do_nodo} ||''sucesso'' || rowspan="3" |Muda o nodo ativo | ||
+ | |- | ||
+ | |404 || || rede ou instância não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/NUM || rowspan="3" |DELETE ||rowspan="3" | ||200 || ||''sucesso'' || rowspan="3" |Encerra uma instância (termina a execução de uma rede) | ||
+ | |- | ||
+ | |404 || || rede ou instância não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/NUM/hostlab || rowspan="3" |GET ||rowspan="3" | ||200 ||['arq', 'arq2', ...] ||''sucesso'' || rowspan="3" |Obtém uma listagem dos arquivos contidos no diretório ''hostlab'' de uma instância | ||
+ | |- | ||
+ | |404 || || rede ou instância não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/NUM/hostlab/path || rowspan="3" |GET ||rowspan="3" | ||200 ||conteúdo do arquivo (''depende do conteúdo'') ||''sucesso'' || rowspan="3" |Obtém o arquivo ''path'', contido no diretório ''hostlab'' de uma instância | ||
+ | |- | ||
+ | |404 || || rede ou instância não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |- | ||
+ | |rowspan="3" |/netkit/ID/NUM/hostlab/path || rowspan="3" |POST ||rowspan="3" | conteúdo do arquivo (''depende do conteúdo'')||200 || ||''sucesso'' || rowspan="3" |Cria o arquivo ''path'' dentro do diretório ''hostlab'' de uma instância, gravando nele o conteúdo enviado. | ||
+ | |- | ||
+ | |404 || || rede ou instância não existe | ||
+ | |- | ||
+ | |400 || || erro genérico | ||
+ | |} | ||
</font> | </font> | ||
− | {{Collapse bottom | Aula 20}} | + | {{Collapse bottom | Aula 25 - adicional}} |
+ | |||
+ | = 16/05/2018: Instalando Kodi = | ||
+ | |||
+ | {{Collapse top | Aula 26}} | ||
+ | <font size="3"> | ||
+ | |||
+ | == Instalação do centro de midia == | ||
+ | |||
+ | Nesta aula iremos efetuar a instalação de um software que será utilizado como centro de mídia, o Kodi. Muitos softwares existem, dentre eles [http://kodi.tv Kodi], [http://www.getmiro.com Miro], [http://www.universalmediaserver.com/ Universal Media Server] e [http://plex.tv/ Plex] (devem existir ainda outros ...). | ||
+ | |||
+ | [[imagem:Xbmc_about.jpg]] [[imagem:Plex.png|400px]] | ||
+ | |||
+ | === Instalando o Kodi === | ||
+ | |||
+ | Para a instalação do Kodi, iremos seguir os passos do site [https://kodi.wiki/view/HOW-TO:Install_Kodi_for_Linux HOW-TO:Install Kodi for Linux]: | ||
+ | |||
+ | sudo apt-get install software-properties-common | ||
+ | sudo add-apt-repository ppa:team-xbmc/ppa | ||
+ | sudo apt-get update | ||
+ | sudo apt-get install kodi | ||
+ | |||
+ | Apesar do guia acima parecer curto e fácil, ele implica alguns conhecimentos para ser realizado a contento - e entendido ! Uma compreensão sobre o que é o sistema operacional Linux, quais seus elementos básicos, e como ele pode ser utilizado, são necessários para essa tarefa. Mas veremos isso à medida que instalarmos o Kodi. | ||
+ | |||
+ | * [https://drive.google.com/file/d/1gET8CP7Cd9negNUBKMF2QwgDq3tkuDTz/view?usp=sharing Videos para testar o Kodi] | ||
+ | * [https://drive.google.com/file/d/126i5oWlFIkXpH3GbaQXqgUm12jczVfCy/view?usp=sharing Fotos para testar o Kodi] | ||
+ | * [https://drive.google.com/file/d/1ofmgChRGOyslkrRDWZCYGDHDQYdozZAh/view?usp=sharing Musicas] | ||
+ | |||
+ | Após a instalação, devemos efetuar alguns ajustes no Kodi, tais como o idioma, local dos arquivos, entre outros. | ||
+ | |||
+ | Os links abaixo irão auxiliar neste processo: | ||
+ | |||
+ | * [https://www.pcguia.pt/2017/11/como-instalar-e-configurar-o-kodi/ Como instalar e configurar o Kodi] | ||
+ | |||
+ | * [https://pplware.sapo.pt/tutoriais/instalar-configurar-kodi-no-pc/ Como instalar e configurar o Kodi no PC] | ||
+ | |||
+ | * [https://iptvglobal.info/controlar-o-kodi-pelo-celular-controle-remoto/ Controlar o Kodi pelo celular] | ||
+ | |||
+ | |||
+ | </font size="3"> | ||
+ | {{Collapse bottom | Aula 26}} | ||
+ | |||
+ | =17/05/2018: Conceitos gerais VOIP, preparação do servidor e instalação do Asterisk e banco de dados= | ||
+ | |||
+ | {{Collapse top | Aula 27}} | ||
+ | <font size="3"> | ||
+ | <b>Telefonia IP ou VoIP: O que é?</b> | ||
+ | ---- | ||
+ | A Comunicação de Voz em Redes IP, chamada de VoIP, consiste no uso das redes de dados que utilizam o conjunto de protocolos das redes IP (TCP/UDP/IP) para a transmissão de sinais de Voz em tempo real na forma de pacotes de dados. | ||
+ | |||
+ | A sua evolução natural levou ao aparecimento da Telefonia IP, que consiste no fornecimento de serviços de telefonia utilizando a rede IP para o estabelecimento de chamadas e comunicação de Voz. | ||
+ | |||
+ | Nessas redes são implementados protocolos adicionais de sinalização de chamadas e transporte de Voz que permitem a comunicação com qualidade próxima àquela fornecida pelas redes convencionais dos sistemas públicos de telefonia comutada ou de telefonia móvel.<br/><br/> | ||
+ | |||
+ | <b>Digitalização de Sinais de Voz</b> | ||
+ | ---- | ||
+ | Nos sistemas tradicionais o sinal de Voz utiliza uma banda de 4 kHz, e é digitalizado com uma taxa de amostragem de 8 kHz para ser recuperado adequadamente (Princípio de Nyquist). Como cada amostra é representada por um byte (8 bits, com até 256 valores distintos), cada canal de Voz necessita de uma banda de 64 kbit/s (8.000 amostras x 8 bits). | ||
+ | |||
+ | Esta forma de digitalização do sinal de Voz atende a recomendação ITU-T G.711 - Pulse code modulation (PCM) of voice frequencies. | ||
+ | |||
+ | Nos sistema de transmissão de Voz sobre IP, onde a demanda por banda é crítica, torna-se necessário utilizar também algoritmos de compressão do sinal de Voz. Esses algoritmos têm papel relevante pela economia de banda que proporcionam. | ||
+ | |||
+ | O seu uso tem sido possível graças ao desenvolvimento dos processadores de sinais digitais (DSP’s), cuja capacidade de processamento tem crescido vertiginosamente. | ||
+ | |||
+ | Estas necessidades incentivaram o desenvolvimento de tecnologias mais complexas para a digitalização e compressão de Voz, e que foram registradas através de recomendações do ITU-T. Estas recomendações são apresentadas na tabela abaixo, com algumas características relevantes. | ||
+ | |||
+ | <div style="text-align: center;">[[Arquivo:codecs.jpg]]</div><br/><br/> | ||
+ | |||
+ | <b>Asterisk</b> | ||
+ | ---- | ||
+ | O Asterisk é a implementação de uma central telefônica PBX (Private Branch eXchange) em software, criado por Mark Spencer em 1999, e distribuído pela Digium livremente seguindo a licençaGPL (GNU General Public License – GPL), ou através de código proprietário. | ||
+ | |||
+ | O nome Asterisk vem do símbolo ‘*’, muito comum no mundo da telefonia. | ||
+ | |||
+ | O Asterisk foi originalmente desenvolvido para Linux, mas atualmente podeser instalado e executado em uma grande variedade de sistemas operacionais, incluindo NetBSD, OpenBSD, FreeBSD, Mac OS X, Solaris e até mesmo Microsoft Windows, onde é conhecido por Asterisk Win32.<br/><br/> | ||
+ | |||
+ | <b>Características do Asterisk</b> | ||
+ | ---- | ||
+ | O Asterisk é um software, baseado na licença GPL (GNU General Public License), que executa todas as funções de uma central telefônica convencional através das principais tecnologias de comunicação existentes no mercado, como por exemplo: linhas telefônicas analógicas, links de telefonia digital via placas de comunicação TDM (Time-Division Multplexing, ou Multiplexaçã ,o por divisão detempo), VoIP (Voice over IP, ou Voz sobre IP) através dos protocolos SIP, H.323, IAX2, MGCP, Skinny,GoogleTalk, Skype, entre outros. | ||
+ | |||
+ | Através do Asterisk é possível estabelecer uma chamada entre qualquer um desses protocolos. O Asterisk é o que chamamos de B2B User Agent, ou melhor, Back-to-Back User Agent, ele estabelece uma chamada telefônica, separando cada “perna” da chamada entre origem e destino, e monitora todo o tráfego de áudio entre esses pontos. Por isso, caso esses pontos estejam utilizando CODECs diferentes, o Asterisk consegue transcodificar o áudio sem qualquer problema. Pode-se dizer que o Asterisk possui todas as funcionalidades das chamadas centrais telefônicas convencionais, como URAs, correio de voz, conferência, distribuição automática de chamadas, entre outras, e caso seja necessário, é possível acrescentar novas funcionalidades ao sistema através do próprio plano de discagem do Asterisk, módulos customizados escritos em C, ou ainda através de scripts escritos em Asterisk Gateway Interface (AGI). *Fonte: Construindo um PBX IP na pratica (Alexandre Keller)<br/><br/> | ||
+ | |||
+ | <b>Codecs</b> | ||
+ | ---- | ||
+ | Um dos componentes necessários para transmissão de voz numa rede de dados é o Áudio CODEC (Codificador-Decodificador). Este componente é o responsável por transformar a voz humana (um sinal analógico) em uma seqüência de bits (um sinal digital) para transmissão numa rede de dados, fazendo amostragens periódicas no sinal de voz. Em equipamentos do tipo gateways VoIP, esses CODECs são implementados através de um componente chamado DSP (Digital Signal Processor). | ||
+ | A introdução dos microprocessadores no final dos anos 70 e início dos anos 80 tornou possível usar técnicas de processamento digital de sinais (Digital Signal Processing) em um range muito maior de aplicações. | ||
+ | Durante os anos 80 a importância crescente do processamento digital de sinais levou vários fabricantes importantes (como Texas Instruments, Analog Devices e Motorola) a desenvolverem os chips DSP, ou seja, microprocessadores especializados com arquiteturas projetadas especificamente para os tipos de operações requeridas ao processamento digital de sinais. | ||
+ | Como um microprocessador de uso geral, um DSP é um dispositivo programável, com seu próprio conjunto de instruções nativas. O uso desses chips associados a algoritmos de compressão permitiu a implementação de diversas tecnologias de CODEC’s. Exemplos de chips DSP são o DSP542 e DSP549 fabricados pela Texas Instruments e usados pela CISCO Systems em seus gateways VoIP [CISCO-CODEC1]. | ||
+ | Cada CODEC provê certa qualidade de voz. A medida de qualidade da voz transmitida é uma resposta subjetiva de um ouvinte. Uma medida comum usada para determinar a qualidade do som produzido pelos CODECs específicos é o MOS (Mean Opinion Score). Com o uso do MOS, um amplo range de ouvintes julgam a qualidade de uma amostra de voz (correspondendo a um CODEC particular) numa escala de 1 a 5. A partir desses resultados, é calculada a média dos scores para atribuir o MOS para aquela amostra [CISCO-CODEC2]. | ||
+ | Na tabela 1 são apresentados alguns scores MOS para os CODECs mais usados. Na Tabela 2 são descritos os scores MOS. | ||
+ | |||
+ | <div style="text-align: center;">[[Arquivo:codecs2.jpg]]</div><br/> | ||
+ | |||
+ | <div style="text-align: center;">[[Arquivo:codecs3.jpg]]</div><br/> | ||
+ | |||
+ | |||
+ | <b>Instalação do Asterisk</b> | ||
+ | ---- | ||
+ | Neste semestre iremos trabalhar com o Asterisk versão 11.1.1, o LibPRI 1.4, que é uma biblioteca Libpri será instalada para que tenhamos suporte aos canais PRI( ISDN, E1, T1 ), e o DAHDI, que é um pacote (Digium Asterisk Hardware Device Interface) nos permite carregar os drivers e configurar diversos tipos de placas de telefonia (para conectar telefones analógicos, linhas telefônicas, linhas digitais e outros). | ||
+ | Antes de qualquer coisa, devemos atualizar o sistema via console de comando: | ||
+ | |||
+ | #apt-get update | ||
+ | #apt-get upgrade | ||
+ | |||
+ | Também devemos instalar algumas dependências: | ||
+ | |||
+ | # apt-get install -y make wget libssl-dev ncurses-dev libnewt-dev libxml2-dev linux-headers-generic g++ libsqlite3-dev | ||
+ | # apt-get install -y mysql-server libmysqld-dev | ||
+ | |||
+ | Para baixar os arquivos do Asterisk, DAHDI e LibPRI, seguem os links abaixo: | ||
+ | |||
+ | [http://downloads.asterisk.org/pub/telephony/asterisk/releases/asterisk-11.1.1.tar.gz Asterisk 11.1.1]<br/> | ||
+ | [http://downloads.asterisk.org/pub/telephony/libpri/old/libpri-1.4.15.tar.gz LibPRI 1.4.15]<br/> | ||
+ | [http://downloads.asterisk.org/pub/telephony/dahdi-linux-complete/dahdi-linux-complete-current.tar.gz DAHDI]<br/> | ||
+ | |||
+ | Campos para o banco de dados: | ||
+ | |||
+ | [https://docs.google.com/document/d/135vf4dUJhMmG0fVqzFXEYPQ095iBzpBU0O7fZz04hZs/edit?usp=sharing Arquivo banco de dados] | ||
+ | |||
+ | <br/><br/> | ||
+ | </font> | ||
+ | {{Collapse bottom | Aula 27}} | ||
+ | |||
+ | =23/05/2018: Comandos e configurações do Asterisk. Criação de ramais= | ||
+ | |||
+ | {{Collapse top | Aula 28}} | ||
+ | <font size="3"> | ||
+ | <b>Comandos Asterisk</b> | ||
+ | |||
+ | Para iniciarmos a utilização do Asterisk, devemos conhecer alguns comandos que serão utilizados no decorrer da disciplina. | ||
+ | |||
+ | |||
+ | <b>Tipo: SIP</b> | ||
+ | |||
+ | |||
+ | Habilitar/Desabilitar Debug do SIP | ||
+ | |||
+ | sip set debug on<br/> | ||
+ | sip set debug off<br/> | ||
+ | |||
+ | '''sip reload''': Reload No arquivo: sip.conf<br/> | ||
+ | '''sip show channels:''' Visualizar canais ativos do Tipo SIP<br/> | ||
+ | '''sip show channel''': Detalhar 1 determinado canal ativo SIP<br/> | ||
+ | '''sip show inuse''': Listar todos os canais/peer existentes no Asterisk<br/> | ||
+ | '''sip show peers''': Visualizar os pares que registraram ou não no Asterisk usando SIP<br/> | ||
+ | '''sip show registry''': Visualizar status do Registro SIP. (Quando o asterisk registra um cliente utilizando SIP)<br/> | ||
+ | '''sip show users''': Visualizar Dispositivos SIP, Plano de Discagem e Senha<br/> | ||
+ | '''sip show channelstats''': Visualizar estatísticas de buffer e jitter na rede e nas chamadas SIP ativas<br/> | ||
+ | |||
+ | |||
+ | <b>Tipo: IAX2</b> | ||
+ | |||
+ | |||
+ | Habilitar/Desabilitar Debug do IAX2:<br/> | ||
+ | |||
+ | iax2 set debug on<br/> | ||
+ | iax2 set debug off<br/> | ||
+ | |||
+ | '''iax2 show channels''': Visualizar canais ativos do Tipo IAX<br/> | ||
+ | '''iax2 show netstats''': Visualizar estatisticas de buffer e jitter na rede e nas chamadas IAX ativas<br/> | ||
+ | '''iax2 show peers''': Visualizar os pares que registraram ou não no Asterisk usando IAX<br/> | ||
+ | '''iax2 show registry''': Visualizar status do Registro SIP. (Quando o asterisk registra um cliente utilizando IAX)<br/> | ||
+ | '''iax2 show stats''': Visualizar estatisticas do IAX<br/> | ||
+ | '''iax2 show users''': Visualizar Dispositivos IAX, Plano de Discagem e Senha<br/> | ||
+ | '''iax show channels''': Visualizar canais ativos do Tipo IAX<br/> | ||
+ | |||
+ | |||
+ | <b>Tipo: Gerenciamento do Asterisk</b><br/> | ||
+ | |||
+ | |||
+ | '''restart now''': Restart Asterisk imediatamente<br/> | ||
+ | '''restart when convenient''': Aguarda inatividade no Asterisk para restartar o Asterisk em seguida<br/> | ||
+ | '''reload''': Reload nas configurações<br/> | ||
+ | '''stop now:''' Shut down no Asterisk imediatamente<br/> | ||
+ | '''dialplan reload''': Reload nos arquivos de configurações do plano de discagem extensions.conf<br/> | ||
+ | '''modules show''': Lista os módulos carregados no sistema<br/> | ||
+ | '''core show uptime''': Visualizar o tempo do Asterisk no Ar<br/> | ||
+ | '''core show version''': Visualizar informações sobre a versão do Asterisk<br/> | ||
+ | |||
+ | |||
+ | <b>Tipo: Comandos Gerais</b><br/> | ||
+ | |||
+ | |||
+ | '''dialplan show''': visualizar informações sobre um contexto<br/> | ||
+ | '''core show queues''': visualizar as filas criadas no Asterisk<br/> | ||
+ | '''soft hangup''': derrubar uma chamada ativa no Asterisk<br/> | ||
+ | '''core show applications''': visualizar informação sobre as aplicações disponíveis<br/> | ||
+ | '''core show application''': “Aplicação”: detalhar informação sobre determinada aplicação<br/> | ||
+ | |||
+ | |||
+ | |||
+ | <b>Preparar o servidor para liberar portas</b> | ||
+ | |||
+ | |||
+ | Devemos efetuar a liberação das portas 5060 e o range de 10000 a 20000 no Iptables do linux. As portas utilizadas no asterisk são definidas no arquivo rtp.conf, localizado no diretório /etc/asterisk/, onde a porta 5060 é padrão para registro do asterisk e o range 10000 a 20000 é padrão para a troca de informações. Somente efetue a alteração das portas em necessidade específica. | ||
+ | |||
+ | <b>Iniciando a configuração dos ramais</b> | ||
+ | |||
+ | |||
+ | O asterisk possui um diretório onde ficam os arquivos de configuração, ele está localizado em /etc/asterisk. | ||
+ | Para definirmos nossos ramais sip, o arquivo de configuração responsável é o sip.conf. | ||
+ | |||
+ | |||
+ | Abaixo segue um exemplo de configuração do arquivo <b>sip.conf</b>: | ||
+ | |||
+ | |||
+ | [general]<br/> | ||
+ | bindport=5060<br/> | ||
+ | bindaddr=0.0.0.0<br/> | ||
+ | context=default<br/> | ||
+ | disallow=all<br/> | ||
+ | allow=ulaw<br/> | ||
+ | allow=alaw<br/> | ||
+ | allow=gsm<br/> | ||
+ | maxexpirey=120<br/> | ||
+ | defaultexpirey=80<br/> | ||
+ | |||
+ | |||
+ | [1000]<br/> | ||
+ | type=friend<br/> | ||
+ | secret=123<br/> | ||
+ | host=dynamic<br/> | ||
+ | qualify=yes<br/> | ||
+ | |||
+ | |||
+ | Onde: | ||
+ | |||
+ | |||
+ | '''bindaddr''': Endereço IP onde o Asterisk irá esperar pelas conexões SIP. O comportamento padrão é esperar em todas as interfaces e endereços secundários. | ||
+ | |||
+ | '''Context''': Configura o contexto padrão onde todos os clientes serão colocados, a menos que seja sobrescrito na definição da entidade. | ||
+ | |||
+ | '''Allow''': Permite que um determinado codec seja usado. | ||
+ | |||
+ | '''Disallow''': Proíbe um determinado codec. | ||
+ | |||
+ | '''Bindport''': Porta que o Asterisk deve esperar por conexões de entrada SIP. O padrão é 5060. | ||
+ | |||
+ | '''maxexpirey''': Tempo máximo para registro em segundos. | ||
+ | |||
+ | '''Defaultexpirey''': Tempo padrão para registro em segundos. | ||
+ | |||
+ | |||
+ | |||
+ | '''[name]''': Quando um dispositivo SIP conecta-se ao Asterisk, ele utiliza a parte username do SIP URI para encontrar o peer/user. | ||
+ | |||
+ | '''Type''': Configura a classe de conexão, as opções são peer, user e friend. | ||
+ | |||
+ | '''Peer''': Entidade para a qual o Asterisk envia chamadas. | ||
+ | |||
+ | '''User''': Entidade que faz chamadas através do Asterisk. | ||
+ | |||
+ | '''Friend''': Os dois ao mesmo tempo. | ||
+ | |||
+ | '''Host''': Configura o endereço IP ou o nome do host. Pode-se usar também a opção ‘dynamic’ onde se espera que o host faça o registro, é a opção mais comum. | ||
+ | |||
+ | '''Secret''': Senha usada para autenticar o peer ou user fazendo uma chamada. | ||
+ | |||
+ | '''Qualify''': caso esteja yes, o asterisk enviará um comando regularmente para verificar se o dispositivo ainda está online. | ||
+ | |||
+ | |||
+ | |||
+ | <b>Plano de discagem</b> | ||
+ | |||
+ | O plano de discagem é um conjunto de instruções. A extensão executa uma ação quando uma chamada é efetuada. | ||
+ | Sintaxe de um comando extension: | ||
+ | |||
+ | |||
+ | exten=> number (name), {priority|label{+|-}offset}[(alias)],application | ||
+ | |||
+ | |||
+ | Para criar um plano de discagem, deve-se editar o arquivo responsável, o extensions.conf. Este arquivo está localizado em /etc/asterisk. Uma parte importante neste arquivo é o contexto <b>general</b>: | ||
+ | |||
+ | [general]<br/> | ||
+ | static=yes<br/> | ||
+ | writeprotect=no<br/> | ||
+ | autofallthrough=yes<br/> | ||
+ | clearglobalvars=no<br/> | ||
+ | priorityjumping=no<br/> | ||
+ | |||
+ | |||
+ | |||
+ | '''static e writeprotect''' – permite salvar o plano de discagem a partir da linha de comando.<br/> | ||
+ | '''Autofallthrough''' – quando um ramal não tiver mais nenhuma opção no seu plano de discagem o Asterisk encerra a chamada com BUSY, CONGESTION ou HANGUP das outras configurações do servidor.<br/> | ||
+ | '''Clearglobalvars''' – determina se as variáveis globais serão limpas e recarregadas a cada vez que ocorrer uma recarga do Asterisk feita com o comando de console.<br/> | ||
+ | '''Priorityjumping''' – determina se as aplicações que suportam saltar prioridades baseado no resultado da operação o farão de forma normal.<br/> | ||
+ | |||
+ | Também devemos criar um contexto que já foi pré definido no ramal criado. No nosso caso se chamará <b>default</b>: | ||
+ | |||
+ | |||
+ | [default]<br/> | ||
+ | exten = 1000,1,Dial(SIP/1000,30)<br/> | ||
+ | exten = 1000,2,Hangup()<br/> | ||
+ | |||
+ | |||
+ | Neste caso usamos duas aplicações, <b>Dial</b> e <b>Hangup</b>, responsáveis por discar e encerrar uma chamada, respectivamente. | ||
+ | |||
+ | As aplicações mais comuns no Asterisk são: | ||
+ | |||
+ | |||
+ | '''Answer''' – Atende uma chamada<br/> | ||
+ | '''PlayBack(arquivo)''' – Reproduz arquivo de som especificado. Os arquivos de som ficam em /var/lib/asterisk/sounds<br/> | ||
+ | '''BackGround(arquivo)''' – Mesma coisa, mais permite a interação com o usuário durante a execução<br/> | ||
+ | '''HangUp''' – Encerra uma chamada<br/> | ||
+ | '''Dial''' – Disca ou conecta dois canais de comunicação<br/> | ||
+ | '''Goto(contexto,extensão,prioridade)''' – Muda a ordem para o contexto, extensão e prioridade especificados<br/> | ||
+ | '''Gosub(contexto,extensão,prioridade)''' – Mesma coisa, mas salva a posição de retorno<br/> | ||
+ | '''NooP''' – imprime na cli do asterisk o termo<br/> | ||
+ | |||
+ | |||
+ | <b>Exercício</b> | ||
+ | |||
+ | |||
+ | Crie 6 ramais (1000, 1001, 1002, 1003, 1004, 1005). | ||
+ | |||
+ | Crie também um plano de discagem que permita a ligação entre todos os ramais. | ||
+ | |||
+ | </font> | ||
+ | {{Collapse bottom | Aula 28}} | ||
+ | |||
+ | =24/05/2018 a 01/06/2018: Aulas suspensas= | ||
+ | |||
+ | {{Collapse top | Aulas suspensas}} | ||
+ | <font size="3"> | ||
+ | |||
+ | ===Aulas suspensas devido a greve dos caminhoneiros=== | ||
+ | |||
+ | </font> | ||
+ | {{Collapse bottom | Aulas suspensas}} | ||
+ | |||
+ | =06/06/2018: Plano de discagem e máscaras= | ||
+ | |||
+ | {{Collapse top | Aula 29}} | ||
+ | <font size="3"> | ||
+ | |||
+ | ===Plano de discagem=== | ||
+ | |||
+ | O plano de discagem define como o Asterisk irá gerenciar as chamadas. Ele consiste de uma lista de instruções ou passos que o Asterisk deveria seguir. Essas instruções são disparadas a partir dos dígitos recebidos de um canal ou aplicação. | ||
+ | O extensions.conf pode ser separado em quatro partes: | ||
+ | |||
+ | * Contextos; | ||
+ | * Extensões; | ||
+ | * Prioridades; | ||
+ | * Aplicações. | ||
+ | |||
+ | |||
+ | ====Contextos==== | ||
+ | |||
+ | Os contextos definem o escopo e permitem separar diferentes partes do plano de discagem, recebem o seu nome dentro de chaves ([]). | ||
+ | No início do arquivo extensions.conf existe um contexto chamado [globals] onde as variáveis globais são definidas e podem ser usadas por todo o plano de discagem. E o contexto [general] que é utilizado para definir alguns parâmetros gerais. | ||
+ | Os contextos estão ligados diretamente aos canais. Quando uma ligação entra no Asterisk por um canal ela é processada dentro do contexto deste canal. | ||
+ | Ex: | ||
+ | |||
+ | [gerentes]<br/> | ||
+ | exten=>9000,1,Playback(gerente) | ||
+ | |||
+ | [visitantes]<br/> | ||
+ | exten=>9000,1,Playback(visitante) | ||
+ | |||
+ | |||
+ | ====Extensões==== | ||
+ | |||
+ | O plano de discagem é um conjunto de instruções. A extensão executa uma ação quando uma chamada é efetuada. | ||
+ | Sintaxe de um comando extension: | ||
+ | |||
+ | exten=> number (name), {priority|label{+|-}offset}[(alias)],application | ||
+ | |||
+ | Exemplo: | ||
+ | |||
+ | exten => 9001,1,Dial(SIP/9001,20) ; Extensão 9001, prioridade 1, disca para o ramal 9001 pelo protocolo SIP, tempo de resposta em segundos.<br/> | ||
+ | Exten => 9001,2,Hangup() ; Extensão 9001, prioridade 2, efetua o desligamento. | ||
+ | |||
+ | Dentro de uma extensão, podemos ter as chamadas variáveis de canal, como abaixo: | ||
+ | |||
+ | exten =>2001,2,DIAL(SIP/${RAMAL}) | ||
+ | |||
+ | Neste exemplo acima, criamos a variável “RAMAL” em tempo de execução, ou seja, na criação do Canal, ou da chamada. | ||
+ | As variáveis de canais são as mais utilizadas normalmente, para trazer informação dos canais normalmente, como nome do canal , nome do contexto, extensão, etc. Vejamos abaixo algumas das variáveis mais usadas: | ||
+ | |||
+ | ${CALLERID} Identificador da chamada (nome ou número)<br/> | ||
+ | ${CALLERIDNAME} O nome do id. Da chamada<br/> | ||
+ | ${CALLERIDNUM} O número do id. Da chamada.<br/> | ||
+ | ${CHANNEL} Nome do Canal atual ou corrente.<br/> | ||
+ | ${CONTEXT} Nome do Contexto atual ou corrente.<br/> | ||
+ | ${DATATIME} Data e hora no formato o YYYY-MM-DD_HH:MM:SS.<br/> | ||
+ | ${DIALPEERNUMBER} Número de que foi chamada.<br/> | ||
+ | ${DIALSTATUS} Status da Chamada.<br/> | ||
+ | ${EXTEN} Extensão da chamada atual ou corrente.<br/> | ||
+ | ${HANGUPCAUSE} Causa do término da chamada<br/> | ||
+ | ${LANGUAGE} A Linguagem Atual.<br/> | ||
+ | ${PRIORITY} Prioridade Atual<br/> | ||
+ | |||
+ | |||
+ | exemplo: | ||
+ | |||
+ | exten => _20XX,1,Dial(SIP/${EXTEN}) | ||
+ | |||
+ | |||
+ | Neste exemplo podemos ver o uso de máscara e da variável do Asterisk EXTEN. Esse é justamente o exemplo que havia falado acima, para evitar o a criação de uma infinidades de canais. Quando um ramal começando com 20 e mais dois números for solicitado, irá chamar a aplicação DIAL para discar para o ramal ( SIP/${EXTEN}), onde esta variável trará o próprio numero discado. Assim precisamos apenas de uma entrada para todos os ramais do tipo 20XX. | ||
+ | |||
+ | |||
+ | ====Aplicações básicas do Asterisk==== | ||
+ | |||
+ | '''Answer''' – Atende uma chamada.<br/> | ||
+ | '''PlayBack(arquivo)''' – Reproduz arquivo de som especificado. Os arquivos de som ficam em /var/lib/asterisk/sounds<br/> | ||
+ | '''BackGround(arquivo)''' – Mesma coisa, mais permite a interação com o usuário durante a execução.<br/> | ||
+ | '''HangUp''' – Encerra uma chamada<br/> | ||
+ | '''Dial''' – Disca ou conecta dois canais de comunicação<br/> | ||
+ | '''Goto(contexto,extensão,prioridade)''' – Muda a ordem para o contexto, extensão e prioridade especificados.<br/> | ||
+ | '''Gosub(contexto,extensão,prioridade)''' – Mesma coisa, mais salva a posição de retorno.<br/> | ||
+ | '''NooP''' – imprime na cli do asterisk o termo.<br/> | ||
+ | |||
+ | Para verificar as aplicações no asterisk, basta digitar n cli do mesmo o seguinte comando: | ||
+ | |||
+ | # ubuntu-server*cli> core show applications | ||
+ | |||
+ | Caso queira uma explicação detalhada de uma aplicação, utilize o comando: | ||
+ | |||
+ | # ubuntu-server*cli> core show application nome_da_aplicacao | ||
+ | |||
+ | Onde o termo nome_da_aplicacao corresponde a aplicação a qual queremos os detalhes. | ||
+ | |||
+ | |||
+ | Formato das extensões | ||
+ | |||
+ | 8000 – numérica<br/> | ||
+ | Alexander – alfanumérica<br/> | ||
+ | 4321/1234 – Numérica com callerID<br/> | ||
+ | _4XXX – Usando máscaras<br/> | ||
+ | s – padrões pré definidos<br/> | ||
+ | |||
+ | Máscaras | ||
+ | |||
+ | _ - início de uma máscaras<br/> | ||
+ | . - aceita n caracteres subsequentes<br/> | ||
+ | [13-9] – qualquer dígito dentro dos colchetes (1, de 3 até 9), mas apenas um deles<br/> | ||
+ | X – qualquer dígito entre 0 e 9<br/> | ||
+ | Z – qualquer dígito entre 1 e 9<br/> | ||
+ | N – qualquer dígito entre 2 e 9<br/> | ||
+ | |||
+ | Prioridades | ||
+ | |||
+ | Prioridades são passos numerados na execução de cada extensão. Cada prioridade chama uma aplicação especifica. Se os números das prioridades não forem sequenciais o Asterisk aborta a execução. A partir da versão 1.2 do Asterisk, tornou-se comum o uso da prioridade “n”, no lugar da associação manual de números, assim como a possibilidade da utilização de labels e aliases. | ||
+ | |||
+ | |||
+ | '''Exercícios''' | ||
+ | |||
+ | # Deve-se criar extensões para ramais com 5 dígitos, permitindo que iniciem com 3 ou 4 e tenham sua numeração entre 30000 e 34999, e também entre 40000 e 44999;<br/> | ||
+ | # Criar extensões para ramais com 5 dígitos iniciando em 6 ou 7 e que tenham sua numeração entre 65000 e 65999, e também entre 75000 e 75999;<br/> | ||
+ | # Criar extensões para ramais com 3 dígitos iniciando com 9 e que tenham numeração entre 901 e 909;<br/> | ||
+ | # Criar extensões para celulares com 9 dígitos mais operadora de longa distância juntamente com o zero (mais 3 dígitos). Deve-se assegurar-se que a operadora de longa distância a ser utilizada é 071 (fictício);<br/> | ||
+ | # Criar a mesma extensão para celulares com 9 dígitos, sem operadora;<br/> | ||
+ | # Criar extensões para telefones fixos com 8 dígitos mais operadora de longa distância juntamente com o zero (mais 3 dígitos). Deve-se assegurar-se que a operadora de longa distância a ser utilizada é 071 (fictício);<br/> | ||
+ | # Criar a mesma extensão para telefones fixos com 8 dígitos, sem operadora.<br/> | ||
+ | |||
+ | |||
+ | '''Observações:''' | ||
+ | |||
+ | * Os celulares iniciam com o dígito 9 e telefones fixos com 2 ou 3. | ||
+ | |||
+ | * Em cada extensão usar uma aplicação para escrever na CLI do Asterisk qual a ligação está sendo efetuada, o número e o nome dado ao ramal. Ex: Esta ligação está sendo efetuada de celular sem operadora de longa distância. | ||
+ | |||
+ | |||
+ | |||
+ | Leituras que podem ser úteis: | ||
+ | |||
+ | [http://stato.blog.br/wordpress/asterisk-parte-3-variaveis-macros-e-mascaras/ Variáveis, Macros e Máscaras] | ||
+ | |||
+ | [https://www.vivaolinux.com.br/etc/extensions.conf-caue.garcia/ Extensions.conf] | ||
+ | |||
+ | |||
+ | |||
+ | <font size="4"> | ||
+ | '''IMPORTANTE''' | ||
+ | </font> | ||
+ | |||
+ | |||
+ | '''13/06/2018''' - Entrega do relatório, o arquivo deve ser enviado para os e-mails ederson.luiz@ifsc.edu.br e mayara.sousa@ifsc.edu.br '''em formato PDF'''. | ||
+ | |||
+ | '''13/06/2018''' - Início do desenvolvimento do projeto final. | ||
+ | |||
+ | '''28/06/2018''' - Última data para apresentação do projeto final. | ||
+ | |||
+ | '''04/07/2018''' - Prova de Recuperação. | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | </font> | ||
+ | {{Collapse bottom | Aula 29}} | ||
+ | |||
+ | =13/06/2018: Definindo Projeto Final= | ||
+ | |||
+ | {{Collapse top | Aula 30}} | ||
+ | <font size="3"> | ||
+ | |||
+ | '''IMPORTANTE''' | ||
+ | |||
+ | |||
+ | 13/06/2018 - Início do desenvolvimento do projeto final. | ||
+ | |||
+ | |||
+ | 13/06/2018 - Entrega do relatório, o arquivo deve ser enviado para os e-mails ederson.luiz@ifsc.edu.br e mayara.sousa@ifsc.edu.br em formato PDF. | ||
+ | |||
+ | |||
+ | 28/06/2018 - Última data para apresentação do projeto final. | ||
+ | |||
+ | |||
+ | 04/07/2018 - Prova de Recuperação. | ||
+ | |||
+ | |||
+ | |||
+ | '''Todas as configurações/orientações abaixo deverão ser efetuadas no computador de cada integrante do grupo.''' | ||
+ | |||
+ | |||
+ | # Instalação de uma nova máquina virtual - Efetuar a instalação do ubuntu Mate 14.04 na máquina virtual Gráfico 1. | ||
+ | # Após instalar o sistema operacional, instale o adicional de convidados do VirtualBox e todas as dependências necessárias. | ||
+ | # Configure o IP fixo em sua placa de rede (as informações serão fornecidas pelos professores) | ||
+ | # Crie um usuário com o nome de cada integrante do grupo usando o comando adduser. | ||
+ | # Defina a senha de cada um dos usuários. | ||
+ | # Crie o grupo Projeto. | ||
+ | # Adicione os usuários criados a este grupo. | ||
+ | # Acrescente, por comandos, ao perfil do usuário seu nome completo e endereço. | ||
+ | # Adicione o repositório do Google Chrome e do Libreoffice 6 e instale este aplicativos. | ||
+ | # Instale o editor de texto VIM, Zoiper, K3B e VLCMediaPlayer. | ||
+ | # Adicione um novo disco no VirtualBox com o tamanho de 13 GB e formate essa partição com sistema de arquivo EXT4. | ||
+ | # Crie um servidor FTP sem acesso anônimo e com as seguintes características: | ||
+ | ## O diretório de acesso de todos os usuários deve ser /srv/ftp/projeto | ||
+ | ## O grupo de acesso dos usuários do servidor FTP deve ser ftpprojeto | ||
+ | ## Deve ser criado um usuário chamado ftp, sem acesso ao terminal, e acesso somente ao diretório /srv/ftp/projeto, para o acesso ao servidor FTP | ||
+ | ## Os usuários criados também deverão ter acesso ao servidor FTP no diretório /srv/ftp/projeto. | ||
+ | # Instale um servidor SSH e faça com que o usuário root não tenha acesso via SSH. Também mude a porta padrão para 2222. | ||
+ | # Instalação do sistema operacional no Raspberry Pi3 - Efetuar a instalação do ubuntu Mate. O nome do computador deve ser Projeto(nº do seu grupo). Deve existir um usuário pji2 com a senha pji22018, também crie os mesmos usuários que foram criados na máquina virtual. Instale os mesmo serviços. | ||
+ | # Configure o roteador Wireless fornecido pelos professores com o SSID da rede sem fio com o nome Projeto(nº do seu grupo). | ||
+ | # Na máquina virtual Gráfico 1 instale o Kodi, baixe alguns vídeos, fotos, áudios e configure os seus respectivos diretórios no Kodi. | ||
+ | ## Configure o controle remoto do Kodi em seu Smartphone. | ||
+ | # Instale o Asterisk 11.1.1, LibPRI 1.4.15 e o DAHDI. | ||
+ | ## Crie um ramal para cada integrante do grupo. | ||
+ | ## Crie também um plano de discagem que permita a ligação entre todos os ramais. | ||
+ | # Efetue o backup utilizando a ferramenta TAR com a extensão tar.gz dos seguintes diretórios (Os backups devem ficar no diretório /root): | ||
+ | ## /etc/asterisk | ||
+ | ## /home | ||
+ | |||
+ | </font> | ||
+ | {{Collapse bottom | Aula 28}} |
Edição atual tal como às 12h55min de 9 de outubro de 2018
Projeto Integrador II
Professores: Ederson Luiz de Souza Santos (ederson.luiz@ifsc.edu.br) e Mayara de Sousa (mayara.sousa@ifsc.edu.br)
Encontros: 4a feira/19:00, 5a feira/19:00
Atendimento paralelo: 3a, 4a, 5a e 6a feira 17:30 h
Coordenadoria pedagógica (Graciane): graciane@ifsc.edu.br (3381-2890, 3381-2842)
Endereço encurtado: http://bit.ly/pji2-2018-1
Objetivo Geral
Implantar rede de dados e telefônica de pequeno porte, típica de um pequeno escritório.
Ementa
Introdução e histórico das telecomunicações e da Internet. Uso de serviços e aplicações oferecidos pelas redes de telecomunicações. Conceitos sobre redes de computadores: comutação de pacotes versus comutação de circuitos, redes locais e rede Internet. Instalação de computadores e integração a uma rede local e a Internet. Sistema operacional Linux. Introdução ao sistema telefônico: telefonia fixa e móvel, centrais de comutação, telefonia IP e convergência. Integração de serviços de voz convencionais e VoIP.
Bibliografia
- FOROUZAN, Behrouz A.; FEGAN, Sophia Chung. Comunicação de dados e redes de computadores. Tradução de Ariovaldo Griesi. 4. ed. São Paulo: McGraw-Hill, 2008. 1134 p., il. ISBN 9788586804885.
- KUROSE, J. e ROSS, K. Redes de Computadores e a Internet: Uma abordagem top-down. Tradução da 3a edição, Addison Wesley, 2006.
- COLCHER, Sérgio. VOIP: voz sobre IP. Rio de Janeiro: Elsevier, 2005.
Material de apoio
- Linux
- Redes
- Outros
Alguns textos interessantes
- A história dos telefones celulares
- Telebrasil (Associação Brasileira de Telecomunicações)
- Telecom no Brasil: um panorama
- Estatísticas sobre telecomunicações no Brasil
- Principais grupos de telecomunicações no Brasil
- Telecomunicações: O Novo Cenário (BNDES)
- Desafios e Oportunidades do Setor de Telecomunicações no Brasil (IPEA)
- Netflix abocanha 34% de todo o tráfego da internet na América do Norte
- Tráfego total VoIP na Internet
- Internet no Brasil 2014 (dados e fontes)
- Internet: como estão as velocidades nos principais países
- Apresentação sobre redes de computadores
- O Mundo Submarino da Internet
- Rede Ipê: a Rede Nacional de Pesquisa (RNP)
- Openwrt no RaspberryPi
Oportunidades para Técnicos em Telecomunicações
- Ofertas de vagas para técnico em Telecom
- Ofertas de vagas para técnico em Telecom no SINE
- Salário médio do Técnico em Telecomunicações no Brasil
Documentários sobre telecomunicações
- História das Telecomunicações
- Inventos: Telefones Celulares (video Discovery)
- Documentário É Logo Ali: parte 1 e parte 2
- Video da Petrobras
Curiosidades
- Telex: um serviço já extinto (?!)
- Submarine Cable Map
- Mapa de Ataques
- Panorama do Tráfego - RNP
- Uma semana na vida do Administrador de Suporte do "Inferno" (humor)
- Vaga de Técnico em Redes na RNP: um exemplo de oferta de emprego
- Empoderar, dar autonomia, não esconder o código
- Carrier Grade Linux (CGL): Linux para Telecomunicações
15/02/2018: Apresentação da disciplina
Aula 1 |
---|
Arquivo apresentação da disciplinaApresentação da disciplina 2018-1 Projeto Integrador IIO componente Curricular Projeto Integrador II deve tratar conceitos sobre redes de computadores, redes locais e rede Internet. Instalação de computadores e integração a uma rede local e a Internet. Sistema operacional Linux. Introdução ao sistema telefônico. Integração de serviços de voz convencionais e VoIP. |
21/02/2018: Sistema operacional e introdução ao Linux
Aula 2 |
---|
O que é GNU/LinuxLinux é o núcleo do sistema operacional, programa responsável pelo funcionamento do computador, que faz a comunicação entre hardware (impressora, monitor, mouse, teclado) e software (aplicativos em geral). O conjunto do kernel e demais programas responsáveis por interagir com este é o que denominamos sistema operacional. O kernel é o coração do sistema. Os principais programas responsáveis por interagir com o kernel foram criados pela fundação GNU. Por este motivo é mais correto nos referenciarmos ao sistema operacional como GNU/Linux ao invés de apenas Linux. Uma distribuição nada mais é que o conjunto de kernel, programas de sistema e aplicativos reunidos num único CD-ROM (ou qualquer outro tipo de mídia). Hoje em dia temos milhares de aplicativos para a plataforma GNU/Linux, onde cada empresa responsável por uma distro escolhe os aplicativos que nela deverão ser inclusos. Como o kernel trabalhaAssim que o computador é ligado, o kernel é acionado e começa a detectar todo o hardware que ele possui e o que precisa para funcionar. Após o carregamento, o núcleo assume outras funções: gerenciar os processos, os arquivos, a memória e os dispositivos periféricos, fazendo com que ele seja o “organizador” de tudo o que acontece na máquina. Após realizar todas essas etapas, o sistema operacional está pronto para funcionar. Ele carrega as funções responsáveis por checar o que deve ser inicializado em nível de software e processos, como, por exemplo, o conteúdo do arquivo /etc/init. Geralmente, o que é carregado é a tela de login do usuário. Com o usuário logado e o sistema operacional trabalhando, o kernel passa a executar suas funções, como a de controlar o uso da memória pelos programas ou a de atender a chamada de uma interrupção de hardware. É possível baixar o código-fonte e o próprio kernel do Linux a partir do site oficial. Nesse endereço não só é possível ter a última versão como também as um pouco mais antigas. Além disso, lá o usuário pode obter informações, reportar bugs e participar de listas de discussão. Distribuições LinuxO Linux possui vários sabores e estes são denominados distribuições. Uma distribuição nada mais é que um kernel acrescido de programas escolhidos a dedo pela equipe que a desenvolve. Cada distribuição possui suas particularidades, tais como forma de se instalar um pacote (ou software), interface de instalação do sistema operacional em si, interface gráfica, suporte a hardware. Então resta ao usuário definir que distribuição atende melhor suas necessidades. Interface gráficaUma das coisas que os usuários mais estranham quando migram para o Linux é a existência de diversas interfaces gráficas, coisa que não é comum no Windows nem no Mac OS X, a não ser quando o fabricante decide fazer alguma alteração.
Diferente do que acontece nesses outros sistema operacionais, no Linux é possível mudar a interface gráfica do sistema.
Mudando a interface gráfica do sistema, a distribuição Linux continua sendo a mesma mas toda a aparência é alterada.
Quem não conhece a diferença entre sistema operacional e interface gráfica pode pensar que se trata de outra distribuição ou até mesmo de outro sistema operacional.
As interfaces gráficas mais conhecidas são Unity, Gnome, KDE, XFCE, LXDE, Cinnamon e Mate. Unity KDE Cinnamon Mate Estrutura de diretórios no LinuxO primeiro choque para quem está vindo do Windows é a estrutura de diretórios do Linux, que não lembra em nada o que temos no Windows. Basicamente, no Windows temos os arquivos do sistema concentrados nas pastas Windows e Arquivos de programas e você pode criar e organizar suas pastas da forma que quiser. No Linux é basicamente o contrário. O diretório raiz está tomado pelas pastas do sistema e espera-se que você armazene seus arquivos pessoais dentro da sua pasta no diretório /home. Mas, as diferenças não param por aí. Para onde vão os programas que são instalados se não existe uma pasta central como a arquivos de programas? E para onde vão os arquivos de configuração se o Linux não possui nada semelhante ao registro do Windows? A primeira coisa com que você precisa se habituar é que no Linux os discos e partições não aparecem necessariamente como unidades diferentes, como o C:, D:, E: do Windows. Tudo faz parte de um único diretório, chamado diretório raiz. Dentro deste diretório temos não apenas todas as partições de disco, mas também o CD-ROM, drive de disquete e outros dispositivos. Entendendo a estrutura de diretórios
Estrutura de diretórios Exercícios1 - Explique o que é:
2 - Qual a diferença entre os sistemas de arquivos do Windows e Linux? 3 - Mude a proteção de tela para Cosmos com tempo de espera de 10 minutos. 4 - Através da Central de programas do Ubuntu Mate, instale os seguintes programas:
5 - Crie um diretório dentro da pasta pessoal do aluno com o nome exercicios. 6 - Para todos os exercícios anteriores, deve-se usar o Libreoffice Writer para descrever os procedimentos, juntamente com a captura da tela no momento da execução da tarefa. Ao finalizar, salve o arquivo com o nome Exercicio aula 2 PJI2 - Seu_nome, no diretório exercicio criado anteriormente.
Envie o arquivo para os seguintes emails, com o título Aula 2 PJI2: 7 - Repasse esse conteúdo para o seu manual do projeto final, criado na aula anterior, via Google Documentos.
|
22/02/2018: Instalação de Sistema Operacional
Aula 3 |
---|
Instalando Sistema OperacionalSistemas operacionais baseados em Linux já foram complicados de usar, ao menos quando comparados ao Windows, mas avanços recentes têm deixado a plataforma mais amigável. No Linux, você vai encontrar alguns programas com os quais está acostumado, como Firefox, Chrome e outros. A maioria, entretanto, não está disponível porque o Linux possui uma comunidade de desenvolvedores que cria, gratuitamente, programas equivalentes para o OS. Não há Photoshop, por exemplo, mas há o GIMP. Não há Microsoft Office, mas há o LibreOffice. Não há Lightroom, mas há o Darktable. Alguns dos programas não são tão bons quanto os disponíveis para Windows, mas por outro lado alguns são até melhores. Cabe a você experimentar. Você não vai precisar digitar nenhum comando complexo ou adquirir conhecimento avançado prévio para fazer isso, mas o processo é longo e varia um pouquinho de computador para computador. É possível que você mexa com certas coisas que nunca viu. Este processo (e o sistema Ubuntu) é utilizado por milhões de pessoas no mundo. Iremos utilizar um software de virtualização chamado Virtualbox. o Virtualbox é fornecido pela Oracle, de forma gratuita. Caso você queira instalar o Virtualbox no seu computador, pode baixar deste site. Lembre-se de baixar a versão adequada para o seu sistema operacional, juntamente com o Extension Pack (software adicional para suporte a diversos dispositivos do seu computador). Para a criação da máquina virtual, deixaremos com a seguinte configuração:
A versão do sistema operacional que utilizaremos é o Ubuntu Mate 14. Ao iniciar a instalação, a primeira etapa é a escolha do idioma e se queremos somente experimentar o Ubuntu ou instalar. a próxima etapa nos dá algumas orientações e também permite escolhermos se queremos baixar atualizações e instalar programas de terceiros. Logo após, teremos que escolher entre a opção de apagar o disco inteiro de forma automatizada pelo instalador ou marcar a opção avançada. Neste momento iremos utilizar a opção de apagar o disco inteiro, pois estaremos entrando nos detalhes de particionamento, sistema de arquivos e tipos de partição em outra aula. Também escolhemos o local onde estamos. Devemos definir o layout do teclado. E por fim, escolhemos o nome, nome do computador, nome de usuário e senha. Agora é só aguardar... Terminada a instalação do sistema operacional, devemos instalar alguns pacotes necessários para que a nossa máquina virtual possa ser utilizada em modo de tela cheia. Para tanto iremos utilizar o terminal do mate e digitar os comandos a seguir:
Após esta instalação, podemos clicar em Dispositivos, e ir na opção Inserir imagem de CD dos adicionais para convidado e executar a aplicação que irá abrir. ExercíciosNeste exercício iremos efetuar a instalação de um sistema operacional diferente. Iremos instalar o Linux Mint. A configuração da máquina virtual deve ser a seguinte:
|
28/02/2018: Uso do SO: processo de boot, componentes do computador, manipulação do arquivos e diretórios
Aula 4 |
---|
Processo de bootQuando ligamos o computador, o primeiro software que é carregado se chama BIOS (Basic input/output system). Ele se encontra em um chip integrado na placa-mãe, que possui uma memória ROM e é a primeira coisa que começa a funcionar quando se liga o computador. A primeira etapa é a leitura das informações contidas no CMOS (Complementary Metal-Oxide-Semiconductor) com as configurações personalizadas pelo usuário no SETUP. O BIOS é responsável pela inicialização do hardware durante o processo de inicialização em computadores e o suporte básico a estes componentes. Sequência de funcionamento do BIOSQuando o computador é ligado, o BIOS opera na seguinte sequência:
MBR (Master Boot Record)Depois do Bios inicializar os componentes do computador, carrega o sistema operacional, lendo o primeiro setor do disco rígido o "Master Boot Record" (MBR), também conhecido como trilha zero ou trilha MBR. No MBR vai o gerenciador de boot. Os dois mais usados no Linux são o lilo e o grub. Na verdade, no MBR mesmo vai apenas um bootstrap, um pequeno software que instrui o BIOS a carregar o executável do lilo ou grub em um ponto específico do HD. Lembre-se que o MBR propriamente dito ocupa um único setor do HD, apenas 512 bytes. Não é possível armazenar muita coisa diretamente nele. O gerenciador de boot utiliza os primeiros 446 bytes do MBR. Os 66 bytes restantes são usados para armazenar a tabela de partições, que guarda informações sobre onde cada partição começa e termina. o gerenciador de boot tem a função de carregar o kernel e, a partir dele todo o restante do sistema. O lilo e o grub podem ser configurados ainda para carregar o Windows ou outros sistema instalados em dual boot. Muitas distribuições configuram isso automaticamente durante a instalação. Inicialmente, o kernel é um arquivo compactado e somente-leitura, o arquivo /boot/vmlinuz. Ele é descompactado em uma área reservada da memória RAM e roda a partir dalí, aproveitando o fato de que a memória RAM é muito mais rápida que o HD. Este executável principal do kernel nunca é alterado durante o uso normal do sistema, ele muda apenas quando você recompila o kernel manualmente ou instala uma nova versão. Depois de carregado, a primeira coisa que o kernel faz é montar a partição raiz, onde o sistema está instalado, inicialmente como somente-leitura. Neste estágio ele carrega o init, o software que inicia o boot normal do sistema, lendo os scripts de inicialização e carregando os módulos e softwares especificados neles. O arquivo de configuração do init é o "/etc/inittab". Ele é geralmente o primeiro arquivo de configuração lido durante o boot. A principal tarefa dele é carregar os demais scripts de inicialização, usados para carregar os demais componentes do sistema e fazer todas as operações de checagem, necessárias durante o boot. Todas essas etapas são realizadas por scripts, localizados na pasta "/etc/init.d", que executam os comandos apropriados para inicializar os serviços e executar as demais operações necessárias. Alguns deles são executados apenas durante o boot (verificando alguma configuração, por exemplo), enquanto outros inicializam serviços que ficam ativos continuamente.
Manipulação de arquivos e diretóriosUma tarefa usual em um sistema operacional é localizar arquivos. Essa procura pode ser baseada no nome ou parte do nome de arquivo, na data de criação ou última modificação, no nome do usuário ou grupo dono, ou outros atributos do arquivo. Pode ser inclusive baseada numa combinação dessas informações. Por exemplo, pode ser necessário procurar todos os arquivos de música ou video, ou então todos os programas (arquivos executáveis) que pertençam ao superusuário (usuário root). Existem programas capazes de fazer tais buscas tanto no ambiente gráfico quanto no modo texto. As buscas a serem realizadas são:
Para iniciar, vamos usar programas gráficos para fazer buscas. Usando o ambiente gráficoO primeiro programa gráfico a ser usado é o caja (ou nautilus em outras versões do Ubuntu que não o Mate), o gerenciador de arquivos disponível no Ubuntu Linux. Para usá-lo para fazer buscas selecione a opção de pesquisa:
Usando a linha de comando (modo texto)O caja funciona como um gerenciador de arquivos e diretórios, possibilitando investigar que arquivos existem em cada diretório, entre outras coisas. Com ele é simples listar o conteúdo de um ou mais diretórios, bastando navegar por sua interface. Mas na linha de comando não há essa facilidade. Nela devem-se usar alguns programas para obter um resultado parecido. Para começar a usar a linha de comando, devem-se conhecer e saber usar programas para navegar por diretórios, listar diretórios, procurar arquivos e diretórios e copiar arquivos. Árvore de diretóriosAntes de iniciarmos o estudo de comandos dos Linux é necessário entendermos como funciona a sua organização de arquivos e diretórios. Isso é importante para conseguirmos especificar adequadamente o caminho de arquivos e diretórios que desejamos manipular quando formos utilizar os mais diversos comandos. Na figura acima é mostrado um exemplo de como são organizados arquivos e diretórios no Linux. Como é possível notar arquivos e diretórios são organizados de forma hierárquica, formando o que se chama de Árvore de Diretórios. No Linux há um diretório de nível superior chamado root que é identificado como apenas uma barra (/). Abaixo deste diretório principal estão organizados hierarquicamente todos os demais diretórios e arquivos existentes. Os diretórios que estão contidos em / são chamados de sub-diretórios. No exemplo mostrado na Figura acima podemos perceber que em / está o sub-diretório home, dentro de home está o sub-diretórios user1 e dentro de user1 estão os sub-diretórios doc e videos.
Por exemplo, o caminho absoluto do diretório doc que aparece na figura é /home/user1/doc. Já se o diretório atual do usuário for /home, o caminho relativo do diretório doc é user1/doc. Diretório atualNa linha de comando existe o conceito de diretório atual ou corrente. Quando se acessa esse tipo de interface, existe um diretório em que operações sobre arquivos são realizadas. Para descobrir o diretório atual usa-se o programa pwd, como mostrado a seguir: msobral@turing:~$ pwd
/home/aluno
Listagem de diretórioNo exemplo anterior, o diretório atual é /home/aluno. Qualquer operação sobre arquivos ou diretórios será feita tendo como base esse diretório. A operação mais simples é a listagem de diretório, que se faz com o programa ls. Aproveitando o exemplo acima, a listagem do diretório atual teria este resultado: msobral@turing:~$ ls
001.jpg iperf-2.0.5.tar.gz prova4-2011-1.odt
002.jpg juliano.tgz prova4-2011-1-rec.odt
003.jpg klaus prr.log
004.jpg livros public_html
005.jpg Makefile.in quartus.cap
006.jpg nhrp.tar radiusd_test.py
007.jpg nohup.out rco2
008.jpg passwd.web rmu
msobral@turing:~$
Como já visto em uma seção anterior, o programa ls pode apresentar mais informações sobre arquivos e subdiretórios se for executado com a opção -l (listagem longa). Experimente executar o ls com esta opação. Para conhecer outras opções e obter mais detalhes, leia a página de manual do comando: man ls
... ou acesse isto. Mudança de diretórioA listagem apresentada revela vários arquivos e subdiretórios existentes no diretório atual. Sabendo que public_html é um subdiretório, pode-se desejar mudar o diretório atual de forma a entrar nesse subdiretório. Isso pode ser facilmente realizado com o programa cd: aluno@turing:~$ cd public_html
aluno@turing:~/public_html$ pwd
/home/aluno/public_html
Diretório atual e diretório acimaO diretório imediatamente acima é referido com .. (dois pontos). Esse é um atalho que possibilita subir um nível de diretório sem conhecer o nome do diretório imediatamente superior. Assim, para voltar ao diretório imediatamente anterior ao diretório atual pode-se fazer isto: aluno@turing:~/public_html$ cd ..
aluno@turing:~$ pwd
/home/aluno
aluno@turing:~/public_html$ pwd
/home/aluno/public_html
aluno@turing:~/public_html$ cd .
aluno@turing:~/public_html$ pwd
/home/aluno/public_html
... nada acontecerá (o diretório atual não será modificado). Criação e remoção de diretórioUm diretório pode ser criado com o comando mkdir. O uso desse comando pede apenas um argumento, que é o nome ou caminho do diretório a ser criado: aluno@M2:~$ pwd
/home/aluno
aluno@M2:~$ mkdir teste
aluno@M2:~$ cd teste
aluno@M2:~$ pwd
/home/aluno/teste
Para remover um diretório usa-se o comando rmdir. Esse diretório deve estar vazio para o comando consiga removê-lo: aluno@M2:~$ pwd
/home/aluno
aluno@M2:~$ rmdir teste
aluno@M2:~$ cd teste
cd: teste: Arquivo ou diretório não encontrado
aluno@M2:~$ rmdir Downloads
rmdir: falhou em remover “Downloads”: Diretório não vazio
Cópia de arquivosA cópia de arquivos na linha de comando envolve usar o programa cp. Com ele podem-se copiar um ou mais arquivos para um diretório de destino. Por exemplo, para copiar o arquivo 001.jpg para dentro do diretório public_html pode-se fazer o seguinte: aluno@M2:~$ cp 001.jpg public_html
O diretório de destino é sempre o último argumento passado ao programa cp. A cópia de múltiplos arquivos pode ser feita listando-os todos antes do diretório de destino: aluno@M2:~$ cp 001.jpg 002.jpg 003.jpg public_html
aluno@M2:~$ cp *.jpg public_html
aluno@M2:~$ cp 00*.jpg public_html
... em que todos os arquivos cujos nomes iniciem com 00 e terminem com .jpg serão copiados. Renomeação de arquivosArquivos podem ser renomeados com o comando mv. Ele pode ser usado de forma muito parecida com o comando cp. A diferença está na remoção do arquivo original, como se ele sumisse de seu diretório de origem e aparecesse no diretório de destino. aluno@M2:~$ mv mulher_de_40.mp3 Musicas
aluno@M2:~$ ls Musicas
mulher_de_40.mp3
aluno@M2:~$ ls mulher_de_40.mp3
não é possível acessar mulher_de_40.mp3: Arquivo ou diretório não encontrado
aluno@M2:~$ mv mulher_de_40.mp3 musica_romantica.mp3
aluno@M2:~$ ls musica_romantica.mp3
musica_romantica.mp3
aluno@M2:~$ ls mulher_de_40.mp3
não é possível acessar mulher_de_40.mp3: Arquivo ou diretório não encontrado
Remoção de arquivosArquivos podem ser removidos com o comando rm. Cuidado ao utilizá-lo ! Uma vez removido, um arquivo não pode ser recuperado ! aluno@M2:~$ rm mulher_de_40.mp3
aluno@M2:~$ ls mulher_de_40.mp3
não é possível acessar mulher_de_40.mp3: Arquivo ou diretório não encontrado
Curingas (wildcards)Curingas são caracteres especiais usados para selecionar vários arquivos ou diretórios de uma só vez. Os curingas podem ser usados em qualquer comando para especificar nomes de arquivos e diretórios. Dois curingas bastante usados são:
Curingas são muito úteis para operações sobre arquivos e diretórios. Por exemplo, para copiar todos os arquivos de música MP3 pode-se usar o curinga *' da seguinte forma: aluno@M2:~$ cp *.mp3 Musica
aluno@M2:~$ mv *.mp? Videos
Procura por arquivosA procura de arquivos e diretórios pode ser realizada na linha de comando com o programa find. Por exemplo, para localizar todos os arquivos ou diretórios chamados default, e que estejam abaixo de /etc: aluno@D1:~$ find /etc -name default -print
/etc/default
/etc/calendar/default
/etc/X11/xinit/xinput.d/default
aluno@D1:~$
find diretório [opções]
... e muitas outras (consulte o manual do find). Exercícios
|
01/03/2018: Uso do SO: processo de boot, componentes do computador, manipulação do arquivos e diretórios - Continuação
Aula 5 |
---|
Uso do SO: processo de boot, componentes do computador, manipulação do arquivos e diretórios - ContinuaçãoContinuação da aula do dia 28/02/2018.
|
07/03/2018: Usuários e grupos
Aula 6 |
---|
Usuários e gruposUm usuário Linux é uma entidade que possui uma identificação no sistema onde os principais parâmetros são: login, senha, e número de identificação. Estas informações permitem ao Linux controlar como o acesso é garantido aos usuários e o que eles podem fazer depois de obter a permissão de acesso. Um grupo é um conjunto de usuários. Cada grupo também possui identificação única no sistema, um nome e um número. O administradores de sistemas normalmente fazem controle de acesso por meio dos grupos. Um usuário no Linux (e no Unix em geral) é definido pelo seguinte conjunto de informações:
As contas de usuários, que contêm as informações acima, podem ficar armazenadas em diferentes bases de dados (chamadas de bases de dados de usuários). Dentre elas, a mais simples é composta pelo arquivo /etc/passwd: root:x:0:0:root:/root:/bin/bash sshd:x:71:65:SSH daemon:/var/lib/sshd:/bin/false suse-ncc:x:105:107:Novell Customer Center User:/var/lib/YaST2/suse-ncc-fakehome:/bin/bash wwwrun:x:30:8:WWW daemon apache:/var/lib/wwwrun:/bin/false man:x:13:62:Manual pages viewer:/var/cache/man:/bin/bash news:x:9:13:News system:/etc/news:/bin/bash uucp:x:10:14:Unix-to-Unix CoPy system:/etc/uucp:/bin/bash roberto:x:1001:100:Roberto de Matos:/data1/roberto:/bin/bash Acima um exemplo de arquivo /etc/passwd Cada linha desse arquivo define uma conta de usuário no seguinte formato: nome de usuário:senha:UID:GID:Nome completo:Diretório inicial:Shell O campo senha em /etc/passwd pode assumir os valores:
O arquivo /etc/shadow armazena exclusivamente as informações relativas a senha e validade da conta. Nele cada conta possui as seguintes informações:
Um exemplo do arquivo /etc/shadow segue abaixo: root:$2a$05$8IZNUuFTMoA3xv5grggWa.oBUBfvrE4MfgRDTlUI1zWDXGOHi9dzG:13922:::::: suse-ncc:!:13922:0:99999:7::: uucp:*:13922:::::: wwwrun:*:13922:::::: roberto:$1$meoaWjv3$NUhmMHVdnxjmyyRNlli5M1:14222:0:99999:7::: Exercício: quando a senha do usuário roberto irá expirar ? Sugestão de leitura para responder a questão anterior: Cálculo de datas com o comando date
Assim como as contas de usuários, os grupos ficam armazenados em bases de dados de usuários, sendo o arquivo /etc/group a mais simples delas: root:x:0: trusted:x:42: tty:x:5: utmp:x:22: uucp:x:14: video:x:33:roberto www:x:8:roberto users:x:100: radiusd:!:108: vboxusers:!:1000: Os membros de um grupo são os usuários que o têm como grupo primário (especificado na conta do usuário em /etc/passwd), ou que aparecem listados em /etc/group. Gerenciamento de usuários e gruposPara gerenciar usuários e grupos podem-se editar diretamente os arquivos /etc/passwd, /etc/shadow e /etc/group, porém existem utilitários que facilitam essa tarefa:
Atividade
|
08/03/2018: Usuários e grupos - Continuação
Aula 7 |
---|
Avaliação 01 - Esta avaliação trata-se do envio referente a primeira parte do relatório, dos assuntos vistos até o momento.
|
14/03/2018: Usuários e grupos - Continuação
Aula 8 |
---|
|
15/03/2018: Linha de comando: arquivos e diretórios; permissões
Aula 9 |
---|
Há uma maneira de restringir o acesso aos arquivos e diretórios para que somente determinados usuários possam acessá-los. A cada arquivo e diretório é associado um conjunto de permissões. Essas permissões determinam quais usuários podem ler, e escrever (alterar) um arquivo e, no caso de ser um arquivo executável, quais usuários podem executá-lo. Se um usuário tem permissão de execução para um diretório, significa que ele pode realizar buscas dentro daquele diretório, e não executá-lo como se fosse um programa. Quando um usuário cria um arquivo ou um diretório, o LINUX determina que ele é o proprietário (owner) daquele arquivo ou diretório. O esquema de permissões do LINUX permite que o proprietário determine quem tem acesso e em que modalidade eles poderão acessar os arquivos e diretórios que ele criou. O super-usuário (root), entretanto, tem acesso a qualquer arquivo ou diretório do sistema de arquivos. O conjunto de permissões é dividido em três classes: proprietário, grupo e usuários. Um grupo pode conter pessoas do mesmo departamento ou quem está trabalhando junto em um projeto. Os usuários que pertencem ao mesmo grupo recebem o mesmo número do grupo (também chamado de Group Id ou GID). Este número é armazenado no arquivo /etc/passwd junto com outras informações de identificação sobre cada usuário, e o arquivo correspondente as senhas criptogravadas dos usuários é /etc/shadow. O arquivo /etc/group contém informações de controle sobre todos os grupos do sistema, e o arquivo correspondente a senhas criptografadas é /etc/gshadow. Assim, pode -se dar permissões de acesso diferentes para cada uma destas três classes. Quando se executa ls -l em um diretório qualquer, os arquivos são exibidos de maneira semelhante a seguinte: > ls -l total 403196 drwxr-xr-x 4 odilson admin 4096 Abr 2 14:48 BrOffice_2.1_Intalacao_Windows/ -rw-r--r-- 1 luizp admin 113811828 Out 31 21:28 broffice.org.2.0.4.rpm.tar.bz2 -rw-r--r-- 1 root root 117324614 Dez 27 14:47 broffice.org.2.1.0.rpm.tar.bz2 -rw-r--r-- 1 luizp admin 90390186 Out 31 22:04 BrOo_2.0.4_Win32Intel_install_pt-BR.exe -rw-r--r-- 1 root root 91327615 Jan 5 21:27 BrOo_2.1.0_070105_Win32Intel_install_pt-BR.exe > As colunas que aparecem na listagem são:
O esquema de permissões está dividido em 10 colunas, que indicam se o arquivo é um diretório ou não (coluna 1), e o modo de acesso permitido para o proprietário (colunas 2, 3 e 4), para o grupo (colunas 5, 6 e 7) e para os demais usuários (colunas 8, 9 e 10). A figura a seguir destaca as classes de permissões mostradas em uma listagem de diretório.
A permissão de acesso a um diretório tem outras considerações. As permissões de um diretório podem afetar a disposição final das permissões de um arquivo. Por exemplo, se o diretório dá permissão de gravação a todos os usuários, os arquivos dentro do diretório podem ser removidos, mesmo que esses arquivos não tenham permissão de leitura, gravação ou execução para o usuário. Quando a permissão de execução é definida para um diretório, ela permite que se pesquise ou liste o conteúdo do diretório. Existem dois modos de definir uma permissão, através do modo Octal e modo Textual. TextualUsamos letras antes das permissões (chmod é o comando para modificar permissões de arquivos): $ chmod u+rw, g+w, o-rwx teste.txt Onde:
OctalO modo Octal tem a mesma função de definir permissões, só que em números. Exemplo: $ chmod 620 teste.txt (comando) (permissão) (arquivo) Tipo de permissão Octal:
A modificação das permissões de acesso a arquivos e diretórios pode ser feita usando-se os utilitários:
Há também o utilitário umask, que define as permissões default para os novos arquivos e diretórios que um usuário criar. Esse utilitário define uma máscara (em octal) usada para indicar que permissões devem ser removidas. Exemplos:
Atividade
|
21/03/2018: Linha de comando: arquivos e diretórios; permissões - Continuação
Aula 10 |
---|
AtividadeConsidere o cenário abaixo relativo a grupos e usuários:
Arquivos de usuários, grupos e senhas Administrando usuários e grupos no Linux Como Listar os Usuários e Grupos Existentes no Linux?
|
22/03/2018: Linha de comando: Instalação de softwares
Aula 11 |
---|
Instalação de softwareA instalação de software pode ser feita de diferentes maneiras:
No escopo desta disciplina de Projeto Integrador, são usados pacotes de software. Mas nada impede que se demonstre como seria realizar uma instalação a partir do código-fonte, caso exista a curiosidade. No Ubuntu Linux (e também nas distribuições originadas no Debian), o sistema de pacotes de software se chama dpkg (Debian Package). Existem diferentes formas de instalar e remover sofware, dentre elas:
Instalação manual com dpkgPara instalar pacotes de software manualmente, primeiro devem-se obter os respectivos arquivos de instalação. Cada pacote de software está contido em um arquivo com extensão .deb. Esses arquivos podem ser obtidos dos CD e DVD de instalação, ou de repositórios na Internet. Exemplos:
dpkg -i nome_do_pacote.deb
Se o pacote de software não puder ser instalado, uma mensagem de erro é apresentada. Uma causa para esse problema é existirem dependências em relação a outros pacotes de software, os quais devem então ser instalados previamente. Para descobrir as dependência de um pacote podemos utilizar o comando a seguir: # sudo apt-cache depends nome-do-pacote A remoção de um pacote de software pode ser feita assim: dpkg -r nome_do_pacote
Se o pacote a ser removido for dependência para outros pacotes instalados, a remoção será abortada.
dpkg-query -l
A listagem dos arquivos instalados por um pacote é mostrada com este outro comando: dpkg-query -L nome_do_pacote
dpkg-query -p nome_do_pacote
Obtenção automática de softwareOs pacotes de softwares dos sistemas operacionais Ubuntu e Debian são organizados e disponibilizados em repositórios, que são servidores na Internet onde há cópias dos arquivos de instalação desses pacotes. Os repositórios são configurados durante a própria instalação do sistema, ficando registrados no arquivo /etc/apt/sources.list. Esse arquivo pode ser modificado para incluir ou remover repositórios, quando necessário.
Utilizando repositório PPA (Personal Package Archives)PPA quer dizer Personal Package Archives, os repositórios deste tipo nada mais são do quer servidores na internet onde se encontram os programas que não estão nos repositórios oficias da sua distro. Mas essa é uma generalização porque alguns programas que estão na Central de Programas possuem PPA, caso do WINE por exemplo, a diferença entre instalar a versão da Central de Programas e instalar via PPA é que a versão que está na Central de Programas e suas possíveis atualizações já foram testadas e apresentam um nível bom de segurança e estabilidade, porém, não trazem os mesmos recursos muitas vezes, das versões mais recentes, coisa que o PPA trás. Mas antes de adicionar PPAs no seu sistema, procure informações referentes aos desenvolvedores, procedência, etc, pois se trata de programas de terceiros, não oficiais da lista de repositório da versão do seu sistema operacional. O comando em si é simples: # sudo add-apt-repository nome-do-repositorio-ppa Como exemplo, vamos utilizar o PPA do Wine, ele é um software que permite rodar aplicações Windows no Linux: # sudo add-apt-repository ppa:ubuntu-wine/ppa Posteriormente devemos atualizar a lista de repositórios: # sudo apt-get update E por fim instalar o pacote: # sudo apt-get install wine Também podemos remover repositórios PPA, seja pelo fato de não estar mais disponível ou simplesmente porque não queremos mais utilizá-lo. Para isso utilizamos o comando a seguir: # sudo add-apt-repository -r ppa:endereço-do-repositorio e posteriormente atualizamos a lista: # sudo apt-get update
|
28/03/2018: Linha de comando: Instalação de softwares - Continuação
Aula 12 |
---|
Avaliação 02Execute os passos seguintes tanto com instalação manual quanto automática de software.
ederson.luiz@ifsc.edu.br mayara.sousa@ifsc.edu.br
Como usar o APT - Obtendo informações sobre pacotes
|
29/03/2018: Linha de comando: Backups
Aula 13 |
---|
BackupsExistem muitos programas para realizar cópias de segurança no Linux (chamadas de backup). Porém tradicionalmente a forma mais simples de realizar uma cópia pessoal de um conjunto de arquivos e diretórios faz uso de um programa simples chamado tar. tarO programa tar é um utilitário do mundo Unix originalmente criado para backups em fita (daí seu nome: TApe aRchiver, se bem que tar é também um trocadilho que pode significar piche, pois ele de certa forma gruda um arquivo ao outro). O resultado da execução do tar é um arquivo contendo todos os arquivos e diretórios que foram selecionados para inclusão. Esse arquivo tar pode ser então compactado, obtendo-se algo parecido com o que faz zip ou rar. Mas porque não usar então zip e rar ? Afinal, eles existem também no Linux ... No entanto, esses compactadores nasceram no mundo do antigo MS-DOS, e assim não são capazes de armazenar todos os atributos de arquivos que existem em sistemas Unix (informações tais como usuário e grupo dono do arquivo, permissões de acesso, tipo do arquivo, datas de último acesso e modificação). O tar, pelo contrário, consegue preservar esses atributos, e por isto se torna mais adequado para uso no Unix em geral. Uso do tar:
Os usos acima não compactam os arquivos incluídos dentro do arquivo tar. Para compactá-los deve-se adicionar uma opção de compactação:
Parâmetros: -c - cria um novo arquivo tar; -M - cria, lista ou extrai um arquivo multivolume; -p - mantém as permissões originais do(s) arquivo(s); -r - acrescenta arquivos a um arquivo tar; -t - exibe o conteúdo de um arquivo tar; -v - exibe detalhes da operação; -w - pede confirmação antes de cada ação; -x - extrai arquivos de um arquivo tar; -z - comprime ou extrai arquivos tar resultante com o gzip; -j - comprime ou extrai arquivos tar resultante com o bz2; -f - especifica o arquivo tar a ser usado; -C - especifica o diretório dos arquivos a serem armazenados. Compactadores no modo textoVários compactadores de arquivos existem no Linux, e o nautilus simplifica sua seleção e uso. Esses compactadores podem ser usados também no modo texto ... aliás, eles originalmente foram criados para serem usados dessa forma ! O que o nautilus faz é facilitar seu uso por meio de uma interface gráfica. Os principais compactadores são:
Note que os compactadores compress, gzip, bzip2 e xz compactam um arquivo por vez. Assim, com eles não é possível juntar vários arquivos e diretórios dentro de um único arquivo compactado (o que se faz corriqueiramente com zip ou rar ...). Portanto, se for necessário compactar um diretório ou um conjunto de arquivos, o melhor é combinar um compactador com o programa tar.
ExercíciosFaça os exercícios abaixo usando os compactadores no modo texto:
|
04/04/2018: Configuração de rede
Aula 14 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Endereço IPv4HistóriaA internet não foi criada para uso comercial que temos atualmente, foi de fato um projeto militar Americano conhecido como ARPANET que tinha por objetivo conectar vários nós tendo a forma parecida com uma teia de aranha, onde se um nó fosse desconectado não haveria problema com os demais. Com o crescimento da ARPANET nas Universidades Americanas, o principal tráfego de informações eram discussões sobre assuntos acadêmicos entre professores. Nessa época os criadores dessa rede não tinham consciência que esse projeto iria tomar gigantes proporções que hoje presenciamos. Na internet, cada host e cada roteador tem um endereço IP (Internet Protocol), que codifica seu número de rede e seu número de host. Essa combinação é única, ou seja, duas máquinas conectadas a internet não possuem o mesmo endereço IP. Devido ao alto crescimento da ARPANET, após cinco anos houve o surgimento do protocolo TCP/IP (Transmission Control Protocol/Internet Protocol) um protocolo que utilizamos até hoje, com um endereço de 32 bits e mais de 4,2 bilhões de combinações de endereços possíveis, que para época esse número era um exagero. Segundo Vint Cerf (2010), vice-presidente do Google, os endereços de IP podem esgotar em até um ano, foi exatamente o que aconteceu em Fevereiro de 2011. O problema não se agravou mais e anteriormente devido a várias tecnologias e medidas paliativas que surgiram ao longo da década de 1990. Podemos citar CIDR (Classless Inter-Domain Routing), RFC 1918 (Address Allocation for Private Internets), NAT (Network Address Translation) e DHCP (Dynamic Host Configuration Protocol) fizeram com que tardassem esse esgotamento de IP’s na internet.
Esgotamento dos endereços IPv4É importante informar que a divisão dos blocos IPv4 não é nada ponderada, metade dos endereços foram destinados aos Estados Unidos (“criador do backbone, principal estrutura da Internet”) e a outra metade foi distribuída para os demais regiões geográficas do mundo. No inicio da distribuição dos endereços, existiram empresas e universidades que compraram 16 milhões de endereços. Hoje seria raro essas entidades devolverem o que adquiriram para uma melhor redistribuição dos endereços. Mas se essa divisão dos IPv4 fosse de forma igual para tal demanda de sua determinada região, não adiantaria em nada, estaríamos sujeitos do mesmo jeito ao esgotamentos dos IPs. Por esse e outros motivos que a IANA mais tarde necessitou de regras mais rígidas para a distribuição dos IPv4 para o mundo. O IANA (Internet Assigned Numbers Authority) é responsável pelo controle de todos os números IPs e, atualmente, ele realiza suas operações através da ICANN (). A responsabilidade sobre uma parte dos endereços é delegada pela IANA para cada um dos Registros Regionais de Internet, que os gerenciam e distribuem dentro de suas respectivas regiões geográficas. Em nossa região, o responsável é o LACNIC (Latin America and Caribbean Network Information Centre). Classes de endereços IPv4Um endereço IPv4 é formado por 32 bits que é o mesmo que dizermos que possui quatro octetos representados na forma decimal (ex: 192.168.0.1). Uma parte desse endereço (bits mais significativos) indicam-nos a rede e a outra parte (bits menos significativos) indicam-nos qual a máquina dentro da rede. Com o objetivo de serem possíveis redes de diferentes dimensões, foram definidas cinco diferentes classes de endereços IP (Classes: A, B, C, D e E). Originalmente, o espaço de endereçamento IP foi dividido estruturas de tamanho fixo designadas de “classes de endereço”. As principais são a classe A, classe B e classe C. Com base nos primeiros bits (prefixo) de um endereço IP, conseguimos facilmente determinar rapidamente a qual a classe pertence de determinado endereço IP. De forma a resumir a informação relativamente às classes de redes IP, criei a seguinte tabela: Analisando as três principais classes (A, B e C) podemos verificar o seguinte: A classe A possui um conjunto de endereços que vão desde o 1.0.0.0 até 127.0.0.0, onde o primeiro octeto (primeiros 8 bits N.H.H.H) de um endereço IP identifica a rede e os restantes 3 octetos ( 24 bits) irão identificar um determinado host nessa rede. Exemplo de um endereço Classe A – 120.2.1.0
Exemplo de um endereço Classe B – 152.13.4.0
Exemplo de um endereço Classe C – 192.168.10.0
Classes especiaisExistem classes especiais na Internet que não são consideradas públicas, não são consideradas como endereçáveis, são reservadas, por exemplo, para a comunicação com uma rede privada ou com o computador local ("localhost").
Rede privadaNa arquitetura para endereçamentos da Internet, uma rede privada (private network) é uma rede que usa o espaço privado de endereços IP, seguindo os padrões estabelecidos pela RFC 1918 para redes IPv4 e RFC 4193 para IPv6. Estes endereços são associados aos dispositivos que precisam se comunicar com outros dispositivos em uma rede privada (que não faz parte da Internet). As redes privadas estão se tornando muito comuns nos escritórios (LAN), pois não há a necessidade de que todos os computadores de uma organização possuam um IP universalmente endereçável. Outra razão que torna importante os IPs privados, é o número limitado de IPs públicos. O IPv6 foi criado para resolver este último problema. Os Roteadores são configurados para descartar qualquer tráfego que use um IP privado. Este isolamento garante que uma rede privada tenha uma maior segurança pois não é possível, em geral, ao mundo externo criar uma conexão direta a uma máquina que use um IP privado. Como as conexões não podem ser feitas entre diferentes redes privadas por meio da internet, diferentes organizações podem usar a mesma faixa de IP sem que haja conflitos (ou seja, que uma comunicação chegue acidentalmente a um elemento que não deveria). Se um dispositivo em uma rede privada deve se comunicar com outras redes, é necessário que haja um "gateway" para garantir que a rede externa seja vista com um endereço que seja "real" (ou público) de maneira que o roteador permita a comunicação. Normalmente este gateway será um service NAT (‘’Network address translation’’) ou um Servidor Proxy. Isto, porém, pode causar problemas se a organização tentar conectar redes que usem os mesmos endereços privados. Os endereços atualmente reservados a redes privadas na internet são:
Endereço IPv6HistóriaO IP versão 6 começou a ser desenvolvido no início da década de 1990, com o objetivo de ser a solução definitiva para o esgotamento de endereços IPs na Internet, tendo esse como o principal objetivo. Em 1993, o IESG (Internet Engineering Steering Group) criou um grupo de trabalho para uma nova versão do protocolo IP, o IPNGWG (IP Next Generation Working Group), com base em alguns objetivos que deveriam ser alcançados. O grupo de trabalho, então, selecionou protocolos "candidatos" para a camada de rede da arquitetura TCP/IP. O vencedor foi o SIPP (Simple Internet Protocol Plus), por diferir menos do IPv4 e ter um plano de transição melhor. Mas uma combinação de aspectos positivos dos três protocolos candidatos foi feita e com isso gerou-se a recomendação para a versão 6 do IP em novembro de 1994. O protocolo IPv6 não foi só criado para resolver o problema de quantidades de endereços, foi também para disponibilizar novos serviços e benefícios que não existiam no IPv4 ou que não eram utilizados de forma otimizada. Abaixo podemos citar alguns desses benefícios:
Para a internet para fazer uso das vantagens do IPv6 sobre IPv4, a maioria dos hosts da Internet, bem como as redes de conexão, precisam implantar este protocolo. Enquanto a implantação do IPv6 está acelerando, especialmente na região da Ásia-Pacífico e alguns países europeus, áreas como as Américas e a África são comparativamente um atraso na implantação do IPv6. A troca de tráfego entre as duas redes IPv4 e IPv6 requer tradutores especiais o que torna a rede menos eficiente comparado uma rede completamente IPv6. Os sistemas operacionais modernos dos computadores implementam um protocolo de duplo software para acesso transparente para ambas as redes, quer sejam elas iguais, ou através de um protocolo de tunelamento como 6to4, 6in4, ou Teredo. Em dezembro de 2012, apesar de marcar o seu 14º aniversário, o IPv6 está apenas em sua infância em termos de implantação em todo o mundo em geral. Um estudo realizado em 2008 pelo Google Inc indicou que a penetração do protocolo IPv6 ainda era menos de 1% dos hosts habilitados para a Internet em qualquer país, naquela época.
Formato do endereçamento IPv6Os endereços IPv6 são números de 128 bits (16 bytes). Ao invés de adotar a notação decimal pontuada do IPv4, onde o endereço é formado por quadro bytes separados por ".", o IPv6 representa seu endereço na forma de 8 palavras de 16 bits, separadas por ":". Cada uma das palavras que forma o endereços IPv6 é representada em hexadecimal.
FE80:0000:0000:0000:68DA:8909:3A22:FECA
FE80:0:0:0:68DA:8909:3A22:FECA
FE80::68DA:8909:3A22:FECA
::1, que é equivalente a 0000:0000:0000:0000:0000:0000:0000:0001
FE80::68DA:8909:3A22:FECA/80
Interfaces de redeQualquer dispositivo (físico ou lógico) capaz de transmitir e receber datagramas IP. Interfaces de rede ethernet são o exemplo mais comum, mas há também interfaces PPP (seriais), interfaces tipo túnel e interfaces loopback. De forma geral, essas interfaces podem ser configuradas com um endereço IP e uma máscara de rede, e serem ativadas ou desabilitadas. Em sistemas operacionais Unix a configuração de interfaces de rede se faz com o programa ifconfig: Para mostrar todas as interfaces: aluno@M1:~> ifconfig -a
ppp0 Link encap:Point-to-Point Protocol
inet addr:189.30.70.200 P-t-P:200.138.242.254 Mask:255.255.255.255
UP POINTOPOINT RUNNING NOARP MULTICAST MTU:1492 Metric:1
RX packets:34260226 errors:0 dropped:0 overruns:0 frame:0
TX packets:37195398 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:3
RX bytes:19484812547 (18582.1 Mb) TX bytes:10848608575 (10346.0 Mb)
eth0 Link encap:Ethernet HWaddr 00:19:D1:7D:C9:A9
inet addr:192.168.1.100 Bcast:192.168.1.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:37283974 errors:0 dropped:0 overruns:0 frame:0
TX packets:42055625 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:20939614658 (19969.5 Mb) TX bytes:18284980569 (17437.9 Mb)
Interrupt:16 Base address:0xc000
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:273050 errors:0 dropped:0 overruns:0 frame:0
TX packets:273050 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:21564572 (20.5 Mb) TX bytes:21564572 (20.5 Mb)
aluno@M1:~>
Configuração manual e temporáriaPara configurar uma interface de rede (que fica automaticamente ativada): aluno@M1:~> ifconfig eth0 192.168.1.100 netmask 255.255.255.0
Para desativar uma interface: aluno@M1:~> ifconfig eth0 down
Para ativar uma interface: aluno@M1:~> ifconfig eth0 up
Ao se configurar uma interface de rede, cria-se uma rota automática para a subrede diretamente acessível via aquela interface. Isto se chama roteamento mínimo. aluno@M1:~> ifconfig eth0 192.168.10.0 netmask 255.255.0.0
aluno@M1:~> netstat -rn
Kernel IP routing table
Destination Gateway Genmask Flags MSS Window irtt Iface
192.168.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0
127.0.0.0 0.0.0.0 255.0.0.0 U 0 0 0 lo
dayna@dayna:~>
# adiciona a rota default, que passa pelo roteador 192.168.10.100
route add default gw 192.168.10.100
# Editar o arquivo /etc/resolv.conf
vi /etc/resolv.conf
#Editar o seu conteúdo e inserir a linha abaixo
nameserver 200.135.37.65
aluno@M1:~> ifconfig eth0:0 192.168.1.110 netmask 255.255.255.0
aluno@M1:~> ifconfig eth0:1 192.168.2.100 netmask 255.255.255.0
aluno@M1:~> ifconfig -a
eth0 Link encap:Ethernet HWaddr 00:19:D1:7D:C9:A9
inet addr:192.168.1.100 Bcast:192.168.1.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:37295731 errors:0 dropped:0 overruns:0 frame:0
TX packets:42068558 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:20942258027 (19972.0 Mb) TX bytes:18294794452 (17447.2 Mb)
Interrupt:16 Base address:0xc000
eth0:0 Link encap:Ethernet HWaddr 00:19:D1:7D:C9:A9
inet addr:192.168.1.110 Bcast:192.168.1.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
Interrupt:16 Base address:0xc000
eth0:1 Link encap:Ethernet HWaddr 00:19:D1:7D:C9:A9
inet addr:192.168.2.100 Bcast:192.168.2.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
Interrupt:16 Base address:0xc000
aluno@M1:~>
Configuração permanenteTodo sistema operacional possui alguma forma de configurar suas interfaces de rede, para que sejam automaticamente ativadas no boot com seus endereços IP. Por exemplo, em sistemas Linux Ubuntu e Debian, a configuração de rede se concentra no arquivo /etc/network/interfaces: # This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).
# The loopback network interface
auto lo
iface lo inet loopback
address 127.0.0.1
netmask 255.0.0.0
# a interface ethernet eth0
auto eth0
iface eth0 inet static
address 192.168.1.100
netmask 255.255.255.0
gateway 192.168.1.254
dns-nameservers 200.135.37.65
Esses arquivo é lido pelos scripts ifup e ifdown. Esses scripts servem para ativar ou parar interfaces específicas, fazendo todas as operações necessárias para isto: # Ativa a interface eth0
ifup eth0
# Desativa a interface eth0
ifdown eth0
Para ativar, desativar ou recarregar as configurações de todas as interfaces de rede: # desativa todas as interfaces de rede
sudo /etc/init.d/networking stop
# ativa todas as interfaces de rede
sudo /etc/init.d/networking start
# recarrega as configurações de todas as interfaces de rede
sudo /etc/init.d/networking restart
O que todo host deve possuirCom o que se fez até o momento, pode-se concluir que todo host (computador, tablet, smartphone, ..., qualquer dispositivo que rode aplicações da Internet) precisa de:
|
05/04/2018: Configuração de rede - Subredes
Aula 15 |
---|
Avaliação IntermediáriaAvaliação Intermediária do Semestre 2018.1
Sistema binárioO sistema binário ou de base 2 é um sistema de numeração posicional em que todas as quantidades se representam com base em dois números, ou seja, zero e um (0 e 1). Os computadores digitais trabalham internamente com dois níveis de tensão, pelo que o seu sistema de numeração natural é o sistema binário. Com efeito, num sistema simples como este é possível simplificar o cálculo, com o auxílio da lógica booliana. Em computação, chama-se um dígito binário (0 ou 1) de bit, que vem do inglês Binary Digit. Um agrupamento de 8 bits corresponde a um byte (Binary Term). Um agrupamento de 4 bits, ainda, é chamado de nibble. Um processador é formado por milhares de blocos lógicos complexos, formados por portas lógicas básicas, e o funcionamento destas está amparado por um postulado fundamental à eletrônica digital que determina que um circuito opere apenas com dois níveis de tensão bem definidos. Em um circuito digital TTL (Transistor Transistor Logic), os dois níveis de tensão padronizados são 0V (zero volt) e 5V (cinco volts). Ao projetar um sistema digital, ao invés de trabalhar com níveis de tensão trabalha-se com níveis lógicos, então, no caso do circuito TTL, 0V será representado por “0” e 5V será representado por “1”, e os níveis de tensão entre eles serão ignorados, ou seja, adotar-se-á uma faixa até a qual será considerado nível lógico zero, e a partir dela, nível lógico 1. Neste caso, de 0V a 2,5V temos “0”, e a partir daí até 5V temos “1”. O sistema binário é base para a Álgebra booliana (de George Boole — matemático inglês), que permite fazer operações lógicas e aritméticas usando-se apenas dois dígitos ou dois estados (sim ou não, verdadeiro ou falso, tudo ou nada, ligado ou desligado, 1 ou 0). Toda a electrónica digital e computação estão baseadas nesse sistema binário e na lógica de Boole, que permite representar por circuitos electrónicos digitais (portas lógicas) os números, caracteres, realizar operações lógicas e aritméticas. Os programas de computadores são codificados sob forma binária e armazenados nas mídias (memórias, discos, etc) sob esse formato. Assim, para informação armazenada na memória RAM do computador, o formato será de voltagem mais alta (1) ou mais baixa (0). Em discos magnéticos a binariedade se dará por diferença de polaridade, positiva ou negativa. Convertendo decimal para binárioPara converter um número decimal para binário, basta realizar divisões sucessivas do número decimal por 2 (base do sistema binário) e verificar se essa divisão possui resto ou não. Se possuir, o valor é 1 se não possuir, o valor é 0. Exemplo de conversão do valor 29 para binário:
Convertendo binário para decimalPara converter um número binário para decimal, basta multiplicar cada bit pelo seu valor de posição e somar os resultados. Exemplo de conversão do valor 10101 para decimal:
Estrutura do endereço IPv4O IPv4 é representado na notação de ponto decimal (por exemplo, 192.168.23.245 ), somente para benefício humano, pois os computadores entendem o endereço na sua notação binária nativa com 32 bits de tamanho, compostos de 4 octetos de 8 bits cada, separados por um ponto:
ID de rede + ID de host = 32 bits
Criando SubredesCriar sub-redes é a pratica para subdividir logicamente um espaço de endereços, alterando a máscara de sub-rede de uma rede, dividindo as redes em vários domínios de difusão (broadcast), evitando futuras lentidões com o aumento da rede. A divisão da rede também ajuda em um melhor aproveitamento do bloco de endereços disponível. Dividindo as subredesNesse método, pegamos um bloco de endereços e criamos várias sub-redes do mesmo tamanho, ou seja, com a mesma máscara. Podemos determinar o número de sub-redes que vamos criar, utilizando uma fórmula bem simples: 2 (n2 - n1)
2 (27-24) = 2 3 = 8 subredes
2 (32-27) = 2 5 = 32 endereços
|
11/04/2018: Configuração de rede - Subredes (continuação)
Aula 16 |
---|
Avaliação 03Considerando o IP 200.168.10.66/26, responda:
Dividir a seguinte rede classe C: 229.45.32.0/255.255.255.0. São necessárias, pelo menos, 10 sub-redes. Determinar o seguinte:
Enviar as questões respondidas para:
mayara.sousa@ifsc.edu.br
|
12/04/2018: Acrescentando discos ao computador
Aula 17 | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|
Particionamento do discoDeve-se instalar o sistema operacional com particionamento manual do disco. As partições devem ser:
Partições e sistemas de arquivos
EXT2O sistema de arquivos ext2 é conhecido como "Second Extended FileSystem". Foi desenvolvido para ser mais "eficiente" que o sistema de arquivos "Minix", seu antecessor. O Minix era muito utilizado nas primeiras versões do Linux, e foi utilizado por muitos anos. O sistema de arquivos ext2 não possui journaling e foi substituído pelo ext3. Segundo, a midia formatada deve ser integrada à árvore de diretórios. Essa integração, chamada de montagem, implica ela ser associada a um subdiretório (chamado de ponto de montagem, ou mount point) na árvore de diretórios. Feito isso, a midia pode ser utilizada para guardar ou acessar novos arquivos. EXT3
Essa característica foi uma evolução e tornou o ext3 um sistema de arquivos muito estável e robusto. Como no ext3 só foi adicionado o suporte a journaling, podemos converter um sistema de arquivos ext2 para ext3, adicionado suporte a journaling, e também podemos converter um sistema de arquivos ext3 para ext2, removendo o suporte a journaling.
REISERFS
Sua performance é muito boa, principalmente para um número muito grande de arquivos pequenos. ReiserFS também possui suporte a journaling.
XFS
XFS utiliza muitos recursos de cache com memória RAM, e para utilizar XFS é recomendado utilizar sistemas que possuem redundância de energia.
SWAP
Em alguns lugares ele não é mencionado como um Sistema de Arquivos. VFATO sistema de arquivos VFAT é também conhecido como FAT32 (M$ Windows). O sistema de arquivos VFAT não possui suporte a journaling. É utilizado normalmente para transferir dados entre sistemas M$ Windows e o Linux instalados no mesmo disco, pois pode ser lido e escrito por ambos os sistemas operacionais. O sistema de arquivos VFAT está longe de ser um sistema de arquivos utilizado para Sistemas Linux, exceto para compartilhamento/compatibilidade entre o M$ Windows e Linux. Se você utilizar VFAT no Linux, esteja certo de perder alguns atributos, tais como: permissão de execução, links simbólicos, entre outras coisas. Ambos os sistemas de arquivos ext3 e ReiserFS são maduros o bastante para serem utilizados como padrão no Linux. Esses dois são os mais utilizados pelas distribuições Linux. Tipos de partiçõesPartições primariasQuando vamos particionar um HD, podemos ter no máximo 4 partições primárias. Sistemas baseados em Windows só aceitam ser instalados em partições primárias, e sistemas baseados em Linux ou Mac OS aceitam dar boot em partições lógicas.
Partições estendidasUm tipo especial de partição primária que foi desenvolvido para superar o limite de quatro partições. A partição estendida é um container no interior do qual você pode criar partições lógicas. A própria partição estendida não contém nenhum dado, nem é atribuída a ela uma letra da unidade. Mas as partições lógicas dentro da partição estendida podem conter aplicativos e dados e ter letras da unidade atribuídas a elas. Uma parte de um disco básico que pode conter unidades lógicas. Um partição estendida é usada para ter mais de quatro volumes em um disco básico. Um disco básico pode conter até quatro partições primária ou três partições primária mais uma partição estendida, por exemplo. A partição estendida pode ainda ser dividida em até 255 unidades lógicas.
Partições lógicasSão partições criadas dentro de uma partição estendida, utilizada quando necessitamos de mais partições que as 4 primárias.
Guia rápido sobre criação de partições
ExercíciosCrie um disco adicional na máquina virtual com 20 Gb e crie as seguintes partições:
Formate as partições e monte no diretório /mnt, cada uma em um diretório diferente. Liste as partições montadas, com seus respectivos pontos de montagem, tamanhos e tipo de arquivo.
|
18/04/2018: Servidor FTP
Aula 18 |
---|
O que é um servidor FTPChama-se servidor FTP um servidor que permite, através de uma rede de computadores, um serviço de acesso para usuários a um disco rígido ou servidor de arquivos através do protocolo de transferência de arquivos: File Transfer Protocol. Seu acesso pode ser feito por qualquer usuário da rede ou reservado (com pedido de login e senha). O servidor FTP utiliza o protocolo FTP via navegador ou via cliente ftp dedicado. A diferença de servidor FTP para FTP é que o servidor é um software produzido para promover o gerenciamento FTP e o FTP já é um protocolo de transporte adquirido através do servidor para acesso a certos dados. Exemplos de servidores FTP para Linux/Unix/BSD são :
E se você quiser copiar arquivos de um computador para outro que está do outro lado do mundo? Você provavelmente usaria sua conexão com a Internet. No entanto, por motivos de segurança, é muito incomum compartilhar pastas pela Internet. As transferências de arquivos pela Internet usam técnicas especiais, das quais uma das mais antigas e mais usadas é o FTP. FTP, abreviação de "File Transfer Protocol", pode transferir arquivos entre qualquer computador que tenha uma conexão com a Internet e também funciona entre computadores usando sistemas operacionais totalmente diferentes. A transferência de arquivos de um computador cliente para um computador servidor é chamada de "upload" e a transferência de um servidor para um cliente é "download".
Requisitos para usar o FTPUm cliente de FTP como o Auto FTP Manager instalado no seu computador Determinadas informações sobre o servidor FTP ao qual você deseja se conectar: O endereço do servidor FTP. Isso se parece muito com os endereços que você digita para navegar em sites. Exemplo: o endereço do servidor é "ftp.videodesk.net". Às vezes, o endereço do servidor será fornecido como um endereço numérico, como "64.185.225.87". Um nome de usuário e senha. Alguns servidores FTP permitem que você se conecte a eles anonimamente. Para conexões anônimas, você não precisa de um nome de usuário e senha. Para transferir arquivos, forneça seu software cliente (Auto FTP Manager) com o endereço do servidor, nome de usuário e senha. Após conectar-se ao servidor FTP, você pode usar o Gerenciador de arquivos do Auto FTP Manager para fazer o upload, download e excluir arquivos. Usando o Gerenciador de Arquivos é muito parecido com o trabalho com o Windows Explorer.
FTP e Conexões com a InternetO FTP usa uma conexão para comandos e a outra para enviar e receber dados. O FTP tem um número de porta padrão no qual o servidor FTP "escuta" conexões. Uma porta é um "ponto de conexão lógica" para comunicação usando o Protocolo da Internet (IP). O número de porta padrão usado pelos servidores FTP é 21 e é usado apenas para enviar comandos. Como a porta 21 é usada exclusivamente para enviar comandos, essa porta é chamada deporta de comando. Por exemplo, para obter uma lista de pastas e arquivos presentes no servidor FTP, o Cliente FTP emite um comando "LIST". O servidor FTP, em seguida, envia uma lista de todas as pastas e arquivos de volta para o cliente FTP. Então, o que acontece com a conexão de internet usada para enviar e receber dados? A porta usada para transferir dados é chamada de porta de dados. O número da porta de dados irá variar dependendo do "modo" da conexão. (Veja abaixo os modos ativo e passivo).
Modo de conexão ativa e passivaO servidor FTP pode suportar conexões ativas ou passivas ou ambas. Em uma conexão FTP ativa, o cliente abre uma porta e escuta e o servidor se conecta ativamente a ela. Em uma conexão FTP passiva, o servidor abre uma porta e escuta (passivamente) e o cliente se conecta a ela. Você deve conceder acesso do Auto FTP Manager à Internet e escolher o tipo correto de modo de conexão FTP. A maioria dos programas cliente de FTP seleciona o modo de conexão passiva por padrão porque os administradores do servidor preferem isso como uma medida de segurança. Os firewalls geralmente bloqueiam conexões "iniciadas" de fora. Usando o modo passivo, o cliente FTP (como o Auto FTP Manager) está "chegando" ao servidor para fazer a conexão. O firewall permitirá essas conexões de saída, o que significa que não são necessários ajustes especiais nas configurações do firewall. Se você estiver se conectando ao servidor FTP usando o modo Ativo de conexão, deverá configurar seu firewall para aceitar conexões com a porta que seu cliente FTP abrirá. No entanto, muitos provedores de serviços de Internet bloqueiam conexões de entrada para todas as portas acima de 1024. Os servidores FTP ativos geralmente usam a porta 20 como porta de dados.
InstalaçãoUsaremos o ProFTP como servidor, que é uma das aplicações mais usadas do mundo.
# apt-get install proftpd
A primeira coisa a fazer é modificar a linha "UseIPv6", deixando-a como "off", desabilitando o uso do endereço IPv6. A próxima linha a ser modificada é a do "ServerName", coloque o nome do seu servidor entre as aspas PJI2. Podemos adicionar a opção "AllowForeignAddress", esta linha é a responsável por autorizar as conexões externas. Se estamos usando um FTP, lógico que a intenção não é usá-lo internamente, então, essa linha deve estar presente no arquivo:
Outra opção é a "RequireValidShell", deixando ela como "off", o ProFTPD irá aceitar conexões de usuários que não possuem shell válida no sistema, consequentemente, usuários sem shell não podem utilizar o SSH. Mais uma opção é a "MaxInstances", que define a quantidade de conexões simultâneas que o servidor aceitará. Basicamente, a configuração é essa aí. Reinicie o ProFTPD: # /etc/init.d/proftpd restart
Caso não tenha um interface gráfica, podemos acessar via terminal com o comando ftp ip_do_servidor Será solicitado um usuário com permissão de acessar o servidor, e posteriormente a senha. Os comando para utilização do ftp no terminal são:
Também podemos utilizar um cliente gráfico de FTP. Existem vários no mercado, a grande maioria gratuita. Nós vamos usar o gftp. Para instalar basta executar o comando: # apt-get install gftp Após a instalação, pode abrir o programa e preencher com as informações pedidas:
ExercíciosCrie um servidor FTP sem acesso anônimo e com as seguintes características:
Adicionando ou excluindo um usuário de um grupo
|
19/04/2018: Processos e Servidor SSH
Aula 19 |
---|
ProcessosJá vimos que sistemas operacionais modernos, como Linux, FreeBSD, Windows, e Android, são capazes de executar múltiplos programas ao mesmo tempo. No caso dos sistemas operacionais Unix, e o Linux pertence a essa família, processos são programas em execução. Um programa contém instruções e dados armazenados em um arquivo. Ao ser executado um arquivo, cria-se um processo. O sistema operacional carrega as instruções e dados em memória RAM, e faz o processador executá-las. Múltiplos processos podem ser criados a partir do mesmo arquivo de programa, sendo executados de forma independente. Os detalhes de como manter todos os processos em memória, e revezar suas execuções de forma a parecer que são simultâneos, são responsabilidade do sistema operacional.
Atividade
Servidor SSHSSH: significa Secure Shell Trata-se de um conjunto de padrões que permite estabelecer um canal seguro entre duas máquinas. É considerado seguro, pois utiliza chave criptográfica pública para identificar um computador remoto. Ou seja, além da criptografia de envio de dados padrão, há também o sistema de criptografia pública e privada para identificar um computador na rede.
Instalando e configurando o SSHPara instalarmos o SSH no Ubuntu é muito simples. Basta, estando no shell como root, digitarmos:
# apt-get install openssh-server
Primeiro passo: vamos começar editando o principal arquivo de configuração, o sshd_config encontrado em: /etc/ssh/sshd_config. Para tal, estando no shell como root, digite:
# vim sshd_config
Em port coloque o padrão 22 ou uma de sua escolha. Esse campo diz ao SSH que ele estará escutando as requisições vindas de outros computadores por esta porta ficando assim: port 22 Na linha #AllowUsers, que pode existir ou não (se não existir crie-a), você pode deixá-la comentada para que todos os usuários possam acessar o servidor ou retirar o comentário ("#") e especificar um usuário. A linha pode ficar assim, caso deseje especificar um usuário único em poder de acesso ao servidor remotamente:
# AllowUsers usuario_ssh
Obs. 1: Se você deseja que o root se conecte, não coloque a linha AllowUsers. Obs. 2: Se você deseja que o seu usuário comum conecte-se e não o root, você deverá coloca as duas linhas, então só seu usuário irá conectar, mas ele não poderá virar root. Feito essas configurações, salve o arquivo. Segundo passo: agora precisamos parar e iniciar o serviço fazendo com que nossas configurações entrem em vigor. Para isso, ainda estando como root, digite:
# /etc/init.d/ssh stop
# /etc/init.d/ssh start
|
25/04/2018: Preparando um computador
Aula 20 | ||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Obtendo o computadorO computador de cada equipe precisa ser especificado e então montado. Os componentes necessários para cada computador precisam ser identificados e escolhidos, para então montá-los. Por isso, primeiro precisamos enumerar que componentes são esses. Para ajudar essa tarefa, primeiro vamos entender a estrutura geral de um computador do tipo PC.
Tabela de componentes dos computadoresProcure no seu computador os componentes da tabela abaixo. Identifique o fabricante e modelo, e demais informações úteis.
Videos ilustrativos
ExercíciosOs conceitos e termos técnicos vêm se acumulando gradativamente. Como exercício de compreensão, explique o que significa:
ExercícioVocê recebeu a tarefa de especificar um computador a ser comprado em sua empresa. Esse computador deve ser usado para rodar programas de escritório. A empresa optou por adquirir os componentes em separado, de forma a montar o computador. Sendo assim, selecione todos os componentes desse computador, informando fabricante, modelo e preço. Use componentes disponíveis em mercado atualmente. Inclua figuras para ilustrar as peças do computador que você escolheu (Avaliação em aula).
|
26/04/2018: Utilizando Raspberry Pi
Aula 21 |
---|
Uso de RaspberryPi como computadorRaspberryPi é um projeto com o propósito de disponibilizar computadores de baixo custo e alto desempenho para que pessoas possam aprender, resolver problemas e se divertirem. O computador RaspberryPi, chamado daqui em diante de Rpi, tem tamanho de um cartão de crédito, bastando teclado e mouse USB, monitor com entrada HDMI e fonte de alimentação para ser utilizado. Ele possui 1 GB RAM e processador ARM de quatro núcleos com clock de 1.2 GHz. Para acesso à rede ele possui interfaces de rede ethernet e Wifi, além de Bluetooth.
Instalação do sistema operacional no RpiA instalação do sistema operacional segue praticamente o mesmo procedimento da aula anterior. Porém desta vez será necessário gravar a imagem do sistema operacional em um cartão de memória microSD, que funcionará como o disco rígido do Rpi. De acordo com as instruções contidas no site do Rpi, a instalação deve ser feita assim:
ExercícioMonte 4 equipes e utilize o Raspberry Pi para efetuar as seguintes configurações:
Leituras úteis:
|
02/05/2018: Utilizando Raspberry Pi - Continuação
Aula 22 |
---|
|
03/05/2018: Redes sem fio
Aula 23 | |||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Rede local sem-fio padrão IEEE 802.11 (WiFi)Uma rede local sem-fios (WLAN - Wireless Local Area Network) serve para conectar dispositivos usando sinal de rádio. Hoje em dia estão tão difundidas que não se imagina um lugar sem cobertura por ao menos uma dessas redes, cuja tecnologia se chama WiFi (ou IEEE 802.11, nome oficial do padrão). As pessoas as utilizam para conectar seus smartphones e tablets, além de laptops e mesmo equipamentos diversos (media centers, impressoras, câmeras fotográficas,TVs, e mesmo estações meteorológicas, entre outros). Todos esses dispositivos fazem uso de uma infraestrutura relativamente simples.
Resumindo, para instalar um AP é necessário configurar os seguintes parâmetros:
Experimente investigar os parâmetros de um AP de verdade usando este emulador:
|
09/05/2018: Rotas
Aula 24 | ||||||||
---|---|---|---|---|---|---|---|---|
Mas o que isso tem a ver com redes ? Muita coisa: a forma com que o Google Maps descobre caminhos se baseia nos mesmos conceitos usados para descobrir rotas entre dispositivos na Internet. E voltando a redes de computadores, também é possível descobrir que caminho os pacotes percorrem para ir de um ponto a outro na Internet. Experimento:: use o programa traceroute para descobrir os caminhos percorridos por seus pacotes. Teste-o com vários possíveis destinos:
O que significam as informações mostradas por esse programa ?
Rotas no LinuxCada computador ligado a Internet possui uma tabela de rotas. É por meio de tal tabela que ele sabe como transmitir os pacotes para cada destino. Em seu computador, você pode visualizar essa tabela da seguinte forma: # Isto funciona em qualquer *nix que se preze ...
netstat -rn
aluno@M1:~> ifconfig eth1 192.168.10.1 netmask 255.255.0.0
aluno@M1::~> netstat -rn
Kernel IP routing table
Destination Gateway Genmask Flags MSS Window irtt Iface
192.168.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth1
127.0.0.0 0.0.0.0 255.0.0.0 U 0 0 0 lo
# adiciona a rota default, que passa pelo roteador 192.168.10.100
route add default gw 192.168.10.100
# este comando tem o mesmo efeito que o anterior ...
route add -net 0.0.0.0/0 gw 192.168.10.100
# este comando define que para chegar à rede 191.36.9.0/24
# deve-se usar o gateway 192.168.1.1
route add -net 191.36.9.0/24 gw 192.168.1.1
Rotas, prefixos de rede e máscarasUma rota serve para informar como se chega a um determinado destino. Um destino pode ser um único endereço IP, ou uma subrede (que contém um conjunto de endereços IP). Para que um pacote IP chegue a um destino, deve-se transmiti-lo para o próximo roteador em direção a esse destino. Esse próximo roteador também deve conhecer uma rota para tal destino, repetindo o mesmo processo (reveja o experimento com 'traceroute). Ao menos duas informações compõem cada rota:
Imagine que exista uma subrede contendo os endereços de 192.168.2.0 até 192.168.2.255. Se representarmos esses endereços em binário, podemos ver que os 24 bits mais significativos são os mesmos para todos os endereços:
O que todo host deve possuirCom o que se fez até o momento, pode-se concluir que todo host (computador, tablet, smartphone, ..., qualquer dispositivo que rode aplicações da Internet) precisa de:
ExercíciosResolva estes exercícios sobre subredes, prefixos e máscaras.
|
10/05/2018: Netkit2
Aula 25 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
AVISO: ATUALIZAÇÃO MANUAL PARA VERSÃO 2.xO netkit2 possui um bug que o impede se atualizar. Para corrigi-lo, deve-se atualizá-lo manualmente com este procedimento:
IntroduçãoNetkit2 é um ambiente para experimentos com redes de computadores desenvolvido pela Área de Telecomunicações do IFSC (Câmpus São José), e que se inspirou no Netkit, uma ferramenta semelhante (mas mais simplificada) desenvolvida pela Universidade de Roma, na Itália. Com ele torna-se possível realizar experimentos sobre configuração básica de rede, roteamento, criação de infraestrutura WAN com MPLS, além de dispor de diversos serviços de rede (DNS, WWW, LDAP, e outros). Ele se compõe de máquinas virtuais Linux (implementadas com kernel Linux UML – User Mode Linux), que funcionam como roteadores ou computadores, e hubs Ethernet virtuais (UML switch) para interligar as máquinas virtuais. Para todos os efeitos, cada máquina virtual funciona como se fosse um computador real, possuindo uma ou mais interfaces de rede. Com esses recursos é possível criar redes de configurações arbitrárias para estudar protocolos de comunicação e serviços de rede.
Sistemas Operacionais compatíveis
OBS: A versão utilizada nos laboratórios é o Ubuntu 12.04 LTS InstalaçãoA instalação pode ser feita de forma automática ou manual. Em ambos os casos, é necessário haver 1,5 GB livre em seu disco. O Netkit foi criado para rodar em sistemas operacionais de 32 bits. Mas ele pode ser usado também em sistemas de 64 bits. Nesse caso, devem-se instalar os seguintes pacotes de software (instale-os com apt-get): sudo apt-get install libc6-i386
Tanto para sistemas de 32 ou 64 bits, são necessários os seguintes pacotes de software para o correto funcionamento do Netkit: sudo apt-get install graphviz python-vte bridge-utils uml-utilities
Após instalado, o Netkit pode ser atualizado executando-se netkit2 e usando o menu General->Update. Instalação automática (recomendada)OBS: o instalador assume que a instalação será feita em um sistema operacional Ubuntu 10.04 ou superior,
python netkit2-installer
O instalador será iniciado e apresentará a seguinte tela: Normalmente deve-se usar a opção Install from Network, que faz o download do arquivo de instalação e o instala. Note que esse arquivo de instalação possui pouco mais de 270 MB, e pode demorar para ser copiado pela rede. A opção Install from File pode ser usada se o arquivo de instalação já estiver em seu disco.
Instalação manualPara instalar o Netkit, deve-se obter o arquivo compactado netkit2.tar.bz2 (330 MB):
Você precisa de um computador com Linux, para onde deve copiar os arquivos acima. Não é necessário ter privilégio de superusuário para instalar o Netkit, tampouco para executá-lo. Aliás, NÃO EXECUTE O NETKIT COMO SUPERUSUÁRIO !!! Após copiar o arquivo netkit2.tar.bz2 para seu computador, descompacte-o dentro de um subdiretório à sua escolha. Em seguida edite o arquivo ~/.profile (que contém a configuração do seu shell), e acrescente as seguintes definições de variáveis de ambiente: export NETKIT2_HOME=/home/aluno/netkit2
export PATH=$NETKIT2_HOME/bin:$PATH
Obs: no exemplo acima foi assumido que o Netkit foi instalado em /home/aluno/netkit2 (quer dizer, você descompactou os arquivos dentro de /home/aluno/netkit2). Caso tenha instalado em outro diretório você deve corrigir a definição da variável de ambiente NETKIT2_HOME. Ajustes finaisAlguns ajustes precisam ser feitos manualmente. Em particular, deve-se editar o arquivo sudoers para que o netkit2 tenha permissão de executar alguns comandos. Use o programa visudo para adicionar o comando ${NETKIT2_HOME}/bin/tap.py ao sudoers (substitua ${NETKIT2_HOME} pelo diretório onde o Netkit2 foi instalado). Por exemplo, se ${NETKIT2_HOME} for /home/aluno/netkit2, use o programa visudo para adicionar a seguinte linha (pode ser ao final da tela): aluno ALL=(root) NOPASSWD: SETENV: /home/aluno/netkit2/bin/tap.py
OBS: No Ubuntu 14.04 LTS, recomenda-se desabilitar o menu global da interface Unity. Nesse caso, use o aplicativo dconf-editor para adicionar netkit2 a com -> canonical -> unity-gtk-module -> blacklist (maiores detalhes). A tela do dconf-editor após a modificação está exemplificada a seguir. Testando a instalaçãoPara estrear seu Netkit você pode baixar o arquivo teste.conf, que descreve um experimento. Para rodá-lo siga estes passos:
O experimento de exemplo contém a seguinte rede: Experimente a comunicação entre os computadores dessa rede, usando o comando ping. Investigue também que interfaces de rede existem em cada um deles, usando o comando ifconfig. Veja que rotas estáticas foram definidas usando o comando netstat -rn. Finalmente, para visualizar o tráfego experimente selecionar o ítem de menu Wireshark->any e em seguida fazer ping entre os computadores. Os ítens de menu do netkit2 tem as seguintes funções: Menu File:
Menu Wireshark:
Softwares disponíveis nas máquinas virtuaisA imagem do sistema operacional das máquinas virtuais se baseia no Ubuntu 12.04. Nele foram instalados diversos softwares para a realização de experimentos de rede.
Criação de experimentosPara criar um experimento do Netkit, deve-se escrever um arquivo de configuração com extensão .conf (sugestão: Lab.conf). Esse arquivo deve conter a configuração da rede do seu experimento. Nele devem-se identificar os atributos globais do experimento, as máquinas virtuais que compõem a rede, seus tipos e como se conectam suas interfaces de rede. O tipo de máquina virtual diz respeito ao seu papel na rede, que pode ser:
Máquinas genéricas (computadores simples)Máquinas genéricas são computadores que possuem uma ou mais interfaces de rede. No Netkit eles foram definidos para representar computadores de usuários ou servidores. No exemplo abaixo duas máquinas genéricas, pc1 e pc2, têm suas interfaces ethernet eth0 conectadas à mesma rede local. # Primeiro devem-se definir os tipos de maquinas virtuais do experimento.
# Um computador Linux genérico é do tipo "generic":
# nome_vm[type]=generic
pc1[type]=generic
pc2[type]=generic
# Em seguida podem-se definir as interfaces de rede Ethernet:
# nome_vm[nome_interface]=nome_rede_local:ip=IP/MASCARA
pc1[eth0]=lan0:ip=192.168.0.1/24
pc2[eth0]=lan0:ip=192.168.0.2/24
A rede resultante é: Para ver esse experimento em ação, copie o conteúdo acima para um arquivo (ex: Lab.conf). Em seguida execute o netkit2 e clique o botão Load para carregar esse arquivo de configuração. Assim que tiver concluído o início do experimento, você deve poder acessar as máquinas virtuais pc1 e pc2. Ambas possuem suas interfaces de rede eth0 configuradas com os endereços IP informados em Lab.conf. A figura abaixo mostra a tela do netkit2 com as máquinas virtuais: Quando uma máquina virtual é iniciada, suas interfaces de rede precisam ser configuradas. Além disso, outros comandos podem ser necessários para prepará-la para o experimento, tais como criação de rotas estáticas ou inicialização de serviços de rede. Esses comandos adicionais podem ser adicionados ao arquivo nome_vm.startup (ex: para a máquina virtual pc1 o arquivo deve se chamar pc1.startup). No entanto, algumas opções de configuração mais comuns (como endereços IP de interfaces) podem ser feitas diretamente no arquivo de configuração Lab.conf. Assim, o próprio netkit2 configura automaticamente as máquinas virtuais quando inicia um experimento. Se houver necessidade de editar manualmente os arquivos nome_vm.startup, adicione seus comandos depois da linha: /hostlab/nome_vm-auto.sh
Interligando interfaces de redeNo exemplo anterior, os dois computadores tiveram suas interfaces de rede interligadas. No Netkit o link entre interfaces é especificado por um nome_ de_link, que pode ser uma palavra qualquer a seu critério. Destacando a interligação das interfaces do exemplo anterior, nota-se que o nome do link é lan0: pc1[eth0]=lan0:ip=192.168.0.1/24
pc2[eth0]=lan0:ip=192.168.0.2/24
Assim, todas as interfaces que estiverem associadas ao mesmo nome de link pertencerão ao mesmo enlace. Inclusive é possível conectar mais de duas interfaces ethernet, que assim se comunicarão como se houvesse um hub a interligá-las. Observe que nome_de_link pode ser qualquer coisa. O Netkit não o interpreta nem o associa a qualquer nome de máquina virtual. Ele serve somente para informar as interfaces de rede que devem estar interligadas. Interfaces podem ser declaradas para iniciarem desativadas. Para obter esse efeito, basta acrescentar o atributo down à interface, como neste exemplo: pc1[eth0]=lan0:ip=192.168.0.1/24
# interface eth0 de pc2 inicia desativada
pc2[eth0]=lan0:ip=192.168.0.2/24:down
Usando DHCPInterfaces de rede do tipo ethernet também podem ser configuradas usando DHCP. Para isso, deve-se definir o parâmetro IP da interface de rede da seguinte forma: pc[eth0]=link:ip=dhcp
Para que o DHCP funcione, deve existir ao menos um servidor DHCP dentro do mesmo domínio de broadcast ethernet. Isso se faz definindo o atributo dhcp de uma máquina virtual, como mostrado abaixo: servidor[type]=generic
servidor[eth0]=link:ip=10.0.0.1/24
servidor[dhcp]=eth0:range=10.0.0.10,10.0.0.20:default-lease=7200:gateway=10.0.0.254
O primeiro parâmetro na definição do atributo dhcp, como exemplificado acima, diz respeito à interface de rede onde serão atendidas requisições vindas de clientes DHCP. Mais de uma interface de rede pode ser servida, bastando definir novamente o atributo dhcp para cada interface. Os demais parâmetros seguem explicados na tabela abaixo:
Limitação de banda nas interfaces de redeA taxa de bits máxima em cada interface de rede pode ser limitada por meio do atributo rate. Esse atributo tem como argumento um valor inteiro, que corresponde à taxa em kbps (kilobits por segundo) permitida na interface. # interface eth0 de pc1 tem taxa limitada a 256 kbps
pc1[eth0]=lan1:ip=192.168.0.1/24:rate=256
# interface eth0 de pc2 tem taxa limitada a 512 kbps
pc2[eth0]=lan1:ip=192.168.0.1/24:rate=512
IPv6Endereços IPv6 podem ser atribuídos às interfaces de rede de forma similar a endereços IPv4, porém usando-se o atributo ipv6: pc1[eth0]=lan0:ipv6=aa::1/64
pc2[eth0]=lan0:ipv6=aa::2/64
As regras para escrever endereços IPv6 compactos são válidas para o atributo ipv6. Assim, endereços como ::1/80, aa:bb::6/64, aa:bb:ccdd:1234:33:8899:1122:6677/80 são possíveis de serem usados.
pc1[eth0]=lan0:ip=10.0.0.1/24:noipv6
Rotas estáticasRotas estáticas para redes IPv4 ou IPv6 podem ser adicionadas a qualquer máquina virtual usando o atributo route: pc1[route]=192.168.0.0/24:gateway=192.168.10.10
pc1[route]=172.18.0.0/16:gateway=192.168.10.1
pc1[route]=default:gateway=192.168.10.2
# Rotas IPv6 ... note o uso de default6 para a rota default IPv6
pc1[route]=default6:gateway=a:b::1
pc1[route]=cc:ab::/64:gateway=a:b::1
No exemplo acima foram adicionadas três rotas estáticas IPv4 ao computador pc1. A primeira tem como destino a rede 192.168.0.0/24, que deve ser alcançada via gateway 192.168.10.10. A segunda aponta a rede 172.18.0.0/16 e usa o gateway 192.168.10.1. A terceira é a rota default. No caso de rotas IPv6, note que deve-se usar a palavra-chave default6 para a rota default. Autoconfiguração de endereços e descoberta automática de gateway IPv6 com radvdNo caso de redes IPv6, é possível usar o serviço radvd para a descoberta automática de gateway da rede. Esse serviço possibilita também a configuração automática de endereço IPv6 das interfaces dos computadores de uma rede, como resumido no manual do radvd: radvd is the router advertisement daemon for IPv6. It listens to router solicitations and sends router advertisements
as described in "Neighbor Discovery for IP Version 6 (IPv6)" (RFC 4861). With these advertisements
hosts can automatically configure their addresses and some other parameters. They also can choose a default
router based on these advertisements.
Para usar o radvd, deve-se ativá-lo no gateway da rede para cada interface de rede onde se desejam fazer os anúncios: # radvd somente pode ser ativado em gateways (isso inclui router e outros tipo descendentes de gateway)
r1[type]=gateway
r1[eth0]=link1:ipv6=a:b::1/64
r1[eth1]=link2:ipv6=d:e::fe/64
# ativa o radvd na interface eth0. Os atributos ''min_interval'', ''max_interval'' e ''rdnss'' são opcionais.
r1[radvd]=eth0:min_interval=3:max_interval=10:rdnss=a:b::1
A configuração criada automaticamente para o radvd é simplificada. O exemplo acima geraria o seguinte arquivo de configuração /etc/radvd.conf: interface eth0 {
AdvSendAdvert on;
MinRtrAdvInterval 3;
MaxRtrAdvInterval 10;
prefix a:b:0:0:0:0:0:0/64 {
AdvOnLink on;
AdvAutonomous on;
};
RDNSS a:b::1 {};
};
# declara uma interface no link denominado "lan". Note que não se declara a configuração
# do endereço IPv6
pc[eth0]=lan
# ativa o serviço rdnssd no host "pc"
pc[services]=rdnssd
Rotas estáticas via interfaces PPPNo caso de interfaces PPP, rotas estáticas devem obrigatoriamente ser especificadas da seguinte forma: pc1[route]=192.168.0.0/24:dev=ppp0
# Ou no caso de rota IPv6
pc1[route]=aa:bb::/64:dev=ppp0
A diferença está no fato de que se deve indicar a interface de saída da rota ao invés do gateway. Rotas default (rota padrão)A rota default é um caso especial, e por ser bastante comum existe um atributo específico para sua definição: pc1[default_gateway]=192.168.0.254
# Ou no caso de IPv6
pc1[default_gateway]=aa:bb::1
No exemplo acima, o computador pc1 definiu que seu roteador default deve ser 192.168.0.254. Essa forma curta de definir a rota default funciona somente para rotas que passam por gateways. No caso de rotas por interfaces, deve-se adicioná-las com o atributo route. OBS: no caso de interfaces PPP, não se pode especificar uma rota default com a sintaxe acima. Para essas interfaces, deve-se usar a sintaxe para rotas estáticas em geral: pc1[route]=0.0.0.0/0:dev=ppp0
# Ou no caso de IPv6
pc1[route]=::/0:dev=ppp0
... ou: pc1[route]=default:dev=ppp0
# No caso de IPv6
pc1[route]=default6:dev=ppp0
Enlaces ponto-a-ponto (via portas seriais)No caso de uma rede em que máquinas virtuais se comunicam via portas seriais efetuando enlaces ponto-a-ponto, uma sintaxe ligeiramente diferente deve ser usada em Lab.conf: pc1[type]=generic
pc2[type]=generic
pc1[ppp0]=link0:ip=10.0.0.1/30
pc2[ppp0]=link0:ip=10.0.0.2/30
A diferença está no nome da interface, que deve ser ppp0. Múltiplas interfaces ponto-a-ponto podem existir em cada máquina virtual. Ao iniciarem, as máquinas virtuais terão suas interfaces seriais interligadas. Essas interfaces dentro do Linux são identificadas por /dev/ttyS0, /dev/ttyS1, /dev/ttyS3, e assim por diante (similar a COM1, COM2, COM3, ... do Windows). Assim, dentro das máquinas virtuais podem-se criar enlaces PPP usando-se essas interfaces seriais. No exemplo acima, como foi definido o IP de cada interface ponto-a-ponto, o protocolo PPP será automaticamente ativado quando as máquinas virtuais iniciarem.
# rate: definida em bits por segundo (bps)
# delay: dado em milissegundos (ms)
# ber: valor entre 0 e 1
pc1[ppp0]=link0:ip=10.0.0.1/30:rate=64000:delay=100:ber=0.000001
pc2[ppp0]=link0:ip=10.0.0.2/30:rate=64000:delay=100:ber=0.000001
Nesse exemplo, o enlace link0 tem taxa de 64000 bps, atraso de propagação de 100 ms e BER de . Observe que uma ou mais dessas propriedades pode ser omitida, e que basta defini-las em uma das pontas do enlace.
# A interface ppp0 de pc1 pode ter seu tráfego analisado com wireshark
pc1[ppp0]=link0:ip=10.0.0.1/30:debug=1
# a ppp0 de pc2 não ...
pc2[ppp0]=link0:ip=10.0.0.2/30
Usando a porta serial da máquina realPode-se vincular uma interface serial de uma máquina virtual a uma porta serial da máquina real. Com isso, é possível estabelecer enlaces PPP entre máquinas virtuais que estão em diferentes computadores. Esses computadores devem ter suas interfaces seriais RS-232 interligadas por um cabo serial cross. Essa vinculação é feita quando se escreve o nome de uma interface serial da máquina real no lugar do link, ao se declarar uma interface PPP: pc1[type]=generic
# A interface ppp0 de pc1 está vinculada à interface ttyS0 da máquina real
pc1[ppp0]=ttyS0:ip=10.0.0.1/30
OBS: as interfaces seriais são chamadas de ttyS0 (equivalente a COM1 do DOS/Windows), ttyS1 (equivalente a COM2), e assim por diante. Iniciando serviços de rede automaticamenteServiços de rede, tais como os oferecidos pelos servidores SSH, Apache2 e outros, podem ser iniciados automaticamente usando-se o atributo services: pc[services]=apache2:ssh
Os serviços a serem iniciados devem estar separados por :. Observe que as configurações desses serviços poderão precisar ser ajustadas, dependendo de como se deseja que eles operem. Arquivos de projeto do Netkit: preservando modificações feitas nas máquinas virtuaisNo arquivo de configuração do Netkit (ex: Lab.conf) devem-se listar os diretorios e/ou arquivos a serem preservados em cada vm (pode haver vm sem o que preservar). Assim, ao iniciar a rede cada máquina virtual pode recuperar os arquivos preservados, e ao terminar os salva automaticamente. Por exemplo: pc1[type]=generic
pc2[type]=generic
pc1[eth0]=link0:ip=192.168.0.1/24
pc2[eth0]=link0:ip=192.168.0.2/24
pc1[preserve]=/etc:/usr/local/etc
... vai preservar os diretorios /etc e /usr/local/etc de pc1, porém em pc2 nada será preservado. Os diretorios e arquivos a serem preservados devem estar separados por ":". Quanto mais específicos forem os diretórios listados, menor será a quantidade de arquivos a serem preservados. Para facilitar a cópia da configuração de uma rede virtual, a qual inclui esses arquivos preservados, existem os ítens "Export" e "Import" no menu "File". Ao clicar em "Export", pode-se salvar em um subdiretório qualquer todo um projeto do Netit, o qual é chamado de "Netkit Project File". O nome desses arquivo de projeto é obtido do arquivo de configuração da rede, porém com extensão ".netkit". Ao clicar em "Import" pode-se escolher um projeto salvo previamente, tendo como efeito a restauração dos arquivos preservados das máquinas virtuais e a carga automática do arquivo de configuração. Com isso pode-se copiar o arquivo de projeto entre diferentes computadores, tornando possível reproduzir fielmente uma rede virtual criada e configurada previamente. IMPORTANTE: somente deve-se exportar o arquivo de projeto APÓS terminar a execução da rede virtual. Gateways (computadores que interligam subredes)Neste outro exemplo (contido neste arquivo), o computador pc2 funciona como gateway entre os computadores pc1 e pc3. pc1[type]=generic
pc2[type]=gateway
pc3[type]=generic
pc1[default_gateway]=192.168.0.2
pc3[default_gateway]=192.168.1.2
pc1[eth0]=lan0:ip=192.168.0.1/24
pc2[eth0]=lan0:ip=192.168.0.2/24
pc2[eth1]=lan1:ip=192.168.1.2/24
pc3[eth0]=lan1:ip=192.168.1.3/24
A rede resultante é: NATNAT pode ser ativado em máquinas virtuais do tipo gateway. Em sua configuração deve-se informar qual a interface de saída onde será feito o NAT: pc2[type]=gateway
pc2[nat]=eth1
Assim, todos datagramas que sairem pela interface eth1 do gateway pc2 terão seus endereços IP de origem substituídos pelo endereço IP dessa interface. Uplink para a rede realO Netkit possibilita que se criem links para a rede real, e com isto as máquinas virtuais podem acessar a rede externa e mesmo a Internet. No entanto, o contrário é um pouco mais difícil (se bem que não impossível) devido a forma como o acesso à rede real foi implementado. O link para a rede real funciona como um enlace ponto-a-ponto ethernet entre uma máquina virtual e a máquina real (o sistema hospedeiro), como pode ser visto neste exemplo:
pc1[type]=generic
pc2[type]=gateway
pc1[default_gateway]=192.168.0.2
pc2[default_gateway]=10.0.0.2
pc1[eth0]=link1:ip=192.168.0.1/24
pc2[eth0]=link1:ip=192.168.0.2/24
pc2[eth1]=uplink:ip=10.0.0.1/30
A criação do link para rede externa deve ser feita com o link especial uplink. Ele deve ter um endereço IP que será usado somente para criar o link entre a máquina virtual e o sistema hospedeiro. O IP no sistema hospedeiro é sempre o último endereço possível dentro da subrede especificada (no exemplo, seria o IP 10.0.0.2). pc2[eth1]=uplink:ip=10.0.0.1/30
Se outras máquinas virtuais precisarem acessar a rede externa, devem ter rotas configuradas para usarem o gateway onde foi feito o uplink. Além disso, será necessário ativar o NAT nesse gateway. Por fim, a criaçao do uplink implica executar alguns comandos como root no sistema hospedeiro. Assim, ao ativar a rede o Netkit irá usar o sudo para executar esses comandos. Por isso é possível que a sua senha seja solicitada durante a inicialização da rede virtual. Uplink em modo bridgeÀs vezes uma interface de uma máquina virtual precisa ser exposta na rede real, como se ela pertencesse ao sistema hospedeiro. Neste caso, deve-se criar uma bridge entre a interface da máquina virtual e uma interface real do sistema hospedeiro (de forma semelhante ao que faz o Virtualbox e outros tipos de máquinas virtuais). Uma bridge é um mecanismo existente no Linux para interligar interfaces ethernet em nível de enlace, como se elas formassem um switch. O procedimento para criar uma bridge integrada a uma interface do tipo uplink do Netkit é um tanto trabalhoso, e por isso esse processo foi automatizado. A criação de um uplink em modo bridge deve ser feita usando o parâmetro bridge ao se declarar uma interface de rede, como mostrado abaixo: pc[eth0]=uplink:bridge=eth0:ip=192.168.1.100/24
Neste exemplo, será criada uma bridge entre a interface eth0 da máquina virtual pc e a interface eth0 do sistema hospedeiro. Como com isso a interface da máquina virtual estará exposta na rede real, seu endereço IP pode pertencer à subrede da rede real. Se esse endereço IP for de alguma outra subrede, a máquina virtual não conseguirá se comunicar com as máquinas reais, tampouco acessar a Internet. Mas isso pode ser desejável se a intenção for interligar redes virtuais que estejam sendo executadas em diferentes computadores. Outra possibilidade é configurar a interface com DHCP: pc[eth0]=uplink:bridge=eth0:ip=dhcp
Desta forma, a interface obterá um endereço IP (além de rota default e servidor DNS) do servidor DHCP da rede real. Por fim, é possível definir uma interface sem endereço IP: pc[eth0]=uplink:bridge=eth0
PBX IP (Asterisk)O Netkit possui um tipo de máquina virtual especial para funcionar como um PBX Asterisk. As diferenças entre esse tipo de máquina e gateway é a quantidade de memória a ela reservada (64 MB) e a instalação automática do software Asterisk. Todos os arquivos do Asterisk estão dentro de /usr/local/asterisk. Abaixo há um exemplo de uma rede com um PBX:
A configuração dessa rede está mostrada a seguir: global[compact]=True
#
pbx[type]=pbx
pc1[type]=generic
pc2[type]=generic
#
pbx[eth0]=link1:ip=192.168.1.254/24
pbx[eth1]=link2:ip=192.168.2.254/24
pc1[eth0]=link1:ip=192.168.1.1/24
pc2[eth0]=link2:ip=192.168.2.1/24
pc1[default_gateway]=192.168.1.254
pc2[default_gateway]=192.168.2.254
pbx[preserve]=/usr/local/asterisk/etc
O Asterisk instalado no PBX tem somente canais SIP e IAX2, porém isso é suficiente para realizar muitos experimentos sobre VoIP. Note que na configuração do experimento mostrada acima incluiu-se uma opção para preservar os arquivos contidos em /usr/local/asterisk/etc. Isso é fortemente recomendado, para que as configurações feitas nos canais SIP e IAX2, além do plano de discagem, não sejam perdidos ao se encerrar a execução da rede. Porém para que esses arquivos sejam realmente preservados, deve-se exportar o experimento logo após parar a rede, conforme explicado na seção sobre preservação de arquivos. OBS: o Asterisk não é iniciado automaticamente. Para iniciá-lo execute:/usr/local/asterisk/sbin/asterisk
pbx[services]=asterisk
/usr/local/asterisk/sbin/rasterisk -vvv
Realizando chamadas VoIP no NetkitUm experimento sobre VoIP implica serem feitas chamadas para se testarem as configurações do PBX e para estudar o funcionamento dos protocolos envolvidos. Porém o uso de softphones dentro do Netkit é impraticável, visto que as máquinas virtuais não foram feitas para terem acesso ao microfone e alto-falante (tampouco apresentam ambiente gráfico, o que limita os softphones que poderiam ser usados). Como o objetivo do Netkit é ajudar a criar redes virtuais e realizar experimentos com aplicações que usem essas redes, seria suficiente simular chamadas VoIP para estudar a sinalização e o transporte das streams de audio. Desta forma, no Netkit foram instalados os softwares siprtp e pjsua, que fazem parte do projeto PJSIP (um conjunto de programas de teste e avaliação de desempenho para infraestruturas VoIP baseadas em SIP), e também o software sipp.
Usando o siprtpO programa siprtp funciona em modo cliente-servidor: em um computador executa-se o programa em modo servidor (aguardando chamadas), e no outro executa-se em modo cliente (iniciando chamadas). As chamadas podem ser feitas diretamente ou com a intermediação de um ou mais PBX IP. O exemplo abaixo mostra os comandos necessários para se fazer uma chamada direta entre cliente e servidor:
Chamadas que usam PBX como intermediários podem também ser realizadas, porém há alguns cuidados a tomar para que funcionem a contento:
Usando o pjsuaO pjsua possui muitas funcionalidades que o tornam um agente SIP quase completo (faltaria ao menos suportar re-invite). Para usá-lo existem muitas opções de linha de comando, conforme descrito em seu manual. Aqui se demonstra como fazer uma chamada com dois pjsua registrados em um PBX Asterisk.
Ajustes na configuração do pjsuaO arquivo de configuração pjsua.cfg que foi fornecido contém configuração de demonstração. Ao fazer as suas modificações nas configurações dos PBX para realizar o trabalho, será necessário também ajustar esse arquivo. Abaixo segue o conteúdo do pjsua.cfg que está em fone1 (os números das linhas são apenas informativos, e não fazem parte do pjsua.cfg): #
# User agent:
#
--auto-answer 200
--max-calls 4
--registrar sip:192.168.1.100
--proxy sip:192.168.1.100;lr
--realm *
# Abaixo devem ser especificados os dados da conta SIP
--id sip:100@ifsc.edu.br
--username 100
--password 100
#
# Logging options:
#
--log-level 3
--app-log-level 4
#
# Network settings:
#
--local-port 5060
#
# Media settings:
#
--null-audio
--snd-auto-close 1
--rtp-port 4000
#
# SIP extensions:
#
--use-timer 1
# Desativa deteccao de silencio
--no-vad
O que pode ser necessário modificar são os dados da conta SIP a ser usada pelo pjsua. Isso é especificado nas linhas 10, 11 e 12. Usando o sippA documentação do SIPp mostra vários exemplos e detalha como se podem criar os cenários de teste. Existe também um pequeno manual que pode ser lido com este comando: man sipp
SwitchesSwitches são implementados usando funcionalidades existentes no Linux. Assim, uma máquina virtual devidamente configurada pode se comportar como um switch. As funcionalidades possibilitam fazer experiências com VLANs IEEE 802.1q, agregação de enlaces IEEE 802.1AX, e mesmo com STP IEEE 802.1d. Um switch com 4 portas pode ser criado da seguinte forma: nome[type]=switch
nome[eth0]=port0
nome[eth1]=port1
nome[eth2]=port2
nome[eth3]=port3
Sendo:
O exemplo com um switch (ver a biblioteca de exemplos mais abaixo) mostra como criar uma pequena LAN com switch. Note que a máquina virtual que será o switch (chamada aqui convenientemente de switch) deve declarar suas interfaces normalmente, além de definir que elas operam em modo bridge (i.e. como um switch): switch[type]=switch
pc1[type]=generic
pc2[type]=generic
pc3[type]=generic
pc4[type]=generic
switch[eth0]=port0
switch[eth1]=port1
switch[eth2]=port2
switch[eth3]=port3
pc1[eth0]=port0:ip=192.168.0.1/24
pc2[eth0]=port1:ip=192.168.0.2/24
pc3[eth0]=port2:ip=192.168.0.3/24
pc4[eth0]=port3:ip=192.168.0.4/24
VLANsUm switch pode ter também suas portas em diferentes vlans. Assim, no exemplo abaixo cria-se um switch com 4 portas, porém com 2 portas na vlan 5 e duas na vlan 10 (todas em modo untagged): nome[type]=switch
nome[eth0]=port0:vlan_untagged=5
nome[eth1]=port1:vlan_untagged=10
nome[eth2]=port2:vlan_untagged=10
nome[eth3]=port3:vlan_untagged=5
Sendo:
A configuração acima vai criar uma bridge para cada conjunto de interfaces que estão na mesma VLAN. Nesse exemplo as interfaces operam todas em modo untagged, mas se for necessário que operem em modo tagged deve-se fazer da seguinte forma: nome[type]=switch
nome[eth0]=port0:vlan_tagged=10,20
nome[eth1]=port1:vlan_untagged=10
nome[eth2]=port2:vlan_untagged=10
nome[eth3]=port3:vlan_untagged=5
nome[eth4]=port4
nome[eth5]=port5
No exemplo acima, a interface eth0 estará nas VLANs 10 e 20 em modo tagged. No caso de interfaces em que não se especificam as vlans, como eth4 e eth5, o switch assume implicitamente que estão na vlan 1 e em modo untagged. Com base nos exemplos acima, a sintaxe para definir as VLANs em uma interface de rede de uma máquina virtual deve ser: nome_vm[nome_iface]=nome_link:vlan_untagged=num_vid:vlan_tagged=num_vid1,num_vid2,...
... sendo que tanto vlan_untagged quanto vlan_tagged podem ser omitidos, mas não podem ser usados ao mesmo tempo. Um outro exemplo (também encontrado na biblioteca de exemplos) mostra um switch com duas VLANs, e o computador pc4 atuando como gateway entre as VLANs. O gateway usa duas interfaces virtuais, e assim a porta do switch em que ele está conectado deve operar em modo tagged: switch[type]=switch
pc1[type]=generic
pc2[type]=generic
pc3[type]=generic
pc4[type]=gateway
pc5[type]=generic
pc6[type]=generic
pc7[type]=generic
switch[eth0]=port0:vlan_untagged=5
switch[eth1]=port1:vlan_untagged=5
switch[eth2]=port2:vlan_untagged=5
switch[eth3]=port3:vlan_tagged=5,10
switch[eth4]=port4:vlan_untagged=10
switch[eth5]=port5:vlan_untagged=10
switch[eth6]=port6:vlan_untagged=10
pc1[eth0]=port0:ip=192.168.0.1/24
pc2[eth0]=port1:ip=192.168.0.2/24
pc3[eth0]=port2:ip=192.168.0.3/24
pc4[eth0]=port3:vlan_tagged=(5,ip=192.168.0.4/24),(10,ip=192.168.1.4/24)
pc5[eth0]=port4:ip=192.168.1.5/24
pc6[eth0]=port5:ip=192.168.1.6/24
pc7[eth0]=port6:ip=192.168.1.7/24
Esse exemplo mostra que podem-se definir diretamente os endereços IP das interfaces de rede virtuais. Isso é útil para o caso de se definirem interfaces virtuais em máquinas virtuais do tipo generic, gateway e router (não tem sentido usar isso em switch). No entanto, a sintaxe nesse caso é ligeiramente diferente, pois deve-se colocar entre parênteses o número da vlan e o IP da interface, como destacado abaixo: pc4[eth0]=port3:vlan_tagged=(5,ip=192.168.0.4/24),(10,ip=192.168.1.4/24)
STP (Spanning Tree Protocol)Switches reais usualmente possuem suporte a STP (Spanning Tree Protocol) para possibilitar haver enlaces redundantes em uma rede local. No Netkit podem-se criar redes em que se usa o STP, que deve ser ativado no switches. Um exemplo de rede em que o STP se torna necessário é mostrada na figura abaixo: Para criar essa rede no Netkit pode-se usar a seguinte configuração: sw1[type]=switch
sw2[type]=switch
sw3[type]=switch
pc1[type]=generic
pc2[type]=generic
pc3[type]=generic
# Ativação do STP nos switches
sw1[stp]=on:bridge_priority=1024
sw2[stp]=on:bridge_priority=128
sw3[stp]=on:bridge_priority=500
sw1[eth0]=sw1-sw2
sw1[eth1]=sw1-port1
sw1[eth2]=sw1-sw3
sw2[eth0]=sw1-sw2
sw2[eth1]=sw2-port1
sw2[eth2]=sw2-sw3
sw3[eth0]=sw1-sw3
sw3[eth1]=sw3-port1
sw3[eth2]=sw2-sw3
pc1[eth0]=sw1-port1:ip=192.168.0.1/24
pc2[eth0]=sw2-port1:ip=192.168.0.2/24
pc3[eth0]=sw3-port1:ip=192.168.0.3/24
A configuração do STP se faz pelo atributo especial stp a ser especificado para cada switch. A opção on ativa o STP, e bridge_priority define a prioridade do switch no escopo do STP. Como os switches podem ser configurados com múltiplas vlans, o STP deve ser ativado apropriadamente. Isso significa que cada vlan deve ter o STP rodando de forma independente. A configuração do Netkit para especificar o STP para cada vlan segue abaixo: sw1[type]=switch
# Ativação do STP nos switches
sw1[stp]=on:bridge_priority=1024:vlan=5
sw1[stp]=on:bridge_priority=512:vlan=10
Nesse exemplo, o switch sw1 tem o STP ativado na vlans 5 e 10. Os parâmetros do STP inclusive podem ser diferentes em cada vlan, já que ele opera em cada uma de forma independente (i.e. o STP em uma vlan não interfere com o STP em outra vlan). Vlans em que o stp não foi explicitamente ativado usarão a configuração default do stp, a qual é definida omitindo-se informação sobre vlan: # Configuração default do STP em um switch ... vale para todas as vlans em que
# o stp não foi configurado individualmente.
sw1[stp]=on
# A configuração default pode conter quaisquer opções do stp, menos vlan:
sw2[stp]=on:bridge_priority=2000
Um último detalhe sobre o STP diz respeito ao custo e prioridade de cada porta do switch. No STP usado em switches reais, o custo de uma porta é dado pela sua velocidade. Assim, portas mais velozes têm custo menor que portas mais lentas, como por exemplo portas 1 Gbps comparadas a 100 Mbps. No Netkit não existe essa diferenciação entre as interfaces ethernet por serem emuladas, mas pode-se especificar manualmente o custo de cada interface a ser usado pelo STP. A configuração necessária deve ser colocada em cada porta da seguinte forma: sw1[type]=switch
# Ativação do STP nos switches
sw1[stp]=on:bridge_priority=1024
sw1[eth0]=port0:stp_cost=10
sw1[eth1]=port1:stp_cost=100
Assim, nesse exemplo a interface eth0 do switch sw1 tem custo STP 10, e a interface eth1 tem custo 100. Os custos de interfaces de acordo com a norma IEEE 802.1d pode ser visto na seguinte tabela:
# STP no switch:
# bridge_priority: prioridade do switch no STP
# hello_time: intervalo entre envios de BPDU
# max_age: tempo máximo que o STP pode ficar sem receber uma atualização de BPDU de outro switch
# forward_delay: atraso para enviar uma BPDU notificando uma mudança de configuração do STP
# on: ativa o STP
# off: inicia com STP desativado
sw1[stp]=on:vlan=10:bridge_priority=100:hello_time=2:max_age=10:forward_delay=1
# Porta do switch: pode ter as opções stp_cost (custo da porta) e stp_prio (prioridade da porta)
sw1[eth0]=port0:stp_cost=10:stp_prio=1
Controle de acesso IEEE 802.1xO controle de acesso IEEE 802.1x possibilita liberar ou bloquear portas de switches mediante a identificação de usuários válidos. Para usá-lo no Netkit deve-se fazer o seguinte:
Juntando os dois exemplos acima, pode-se definir uma pequena rede para fins de demonstração do controle de acesso: sw[type]=switch
pc1[type]=generic
pc2[type]=generic
# Podem-se definir quantos usuários e senhas forem desejados.
sw[8021x]=1:users=usuario1/senha1,usuario2/senha2
# A interface eth0 do switch é uma porta autenticadora, mas a interface eth1 não.
sw[eth0]=port0:8021x_authenticator=1
sw[eth1]=port1
pc1[eth0]=port0:8021x_user=usuario1/senha1:ip=10.0.0.1/24
pc2[eth0]=port1:ip=10.0.0.2/24
Ao executar a rede acima, deve-se conseguir fazer um ping entre pc1 e pc2. Se quiser testar com maiores detalhes o controle de acesso e vê-lo em ação, experimente fazer o seguinte:
Definindo um IP de gerenciamentoUm switch pode possuir um endereço IP para fins de gerenciamento. No momento, isso é usado somente para que um switch consiga rodar um servidor Radius e atender pedidos de acesso vindos de outros switches. O IP de gerenciamento precisa estar vinculado a uma das VLANs do switch: sw[management_ip]=192.168.0.10/24:vlan=5
No exemplo acima, o switch sw possui o IP de gerenciamento 192.168.0.10, que está vinculado a VLAN 5. Apenas um IP por switch hpode ser definido. Como o tipo switch especializa o tipo generic, é possível definir rotas em um switch que possui um IP de gerenciamento. Isso pode ser feito da mesma forma que em máquinas virtuais genéricas (i.e. usando os atributos default_gateway ou route). Usando um servidor RadiusEm uma infraestrutura de controle de acesso IEEE 8021.X, usualmente o servidor de autenticação reside em um equipamento em separado. Desta forma, os autenticadores (switches e access points) podem efetuar a autenticação usando uma base de usuários comum. Apesar do padrão IEEE 8021.X não definir como deve ser implementado o servidor de autenticação, os fabricantes de equipamentos adotaram o serviço Radius para assumir esse papel. Com isso, para implantar o servidor de autenticação deve-se instalar um servidor Radius em algum equipamento, e fazer com que os autenticadores o utilizem para para autenticar os acessos. No Netkit a implantação de um servidor Radius foi simplificada e integrada à configuração do controle de acesso descrita no início desta seção. Por questão de simplicidade, o servidor Radius deve ser implantado em um switch. assim, a configuração de um switch que deve operar como servidor Radius é: sw2[8021x]=1:users=u1/p1,u2/p2:radius_clients=10.0.0.10,10.0.0.254
O parâmetro users lista os usuários e senhas autenticados pelo Radius, e radius_clients lista os endereços IP dos clientes Radius (que são os demais switches). Em ambos os casos, as informações devem ser escritas como listas separadas por vírgulas. Os clientes Radius precisam definir que servidor Radius irão utilizar. A configuração de um switch que é cliente Radius poderia ser esta: sw[8021x]=1:radius_server=10.0.0.5
Note que os clientes Radius devem ser capazes de alcançarem o servidor Radius. Quer dizer, se clientes e servidor Radius estiverem em subredes IP diferentes, devem existir rotas para que eles possam se comunicar. Um exemplo de uma rede com dois switches, sendo um deles um servidor Radius, está mostrada a seguir: Usando múltiplas VLANs
Quando um switch que é autenticador IEEE 802.1x possui múltiplas VLANs, Usando freeradiusAgregação de enlace (bonding)O Linux possui suporte a agregação de enlaces, em que se agrupam interfaces ethernet de forma a parecerem uma única interface (chamado de Linux Channel Bonding). A interface agregada tem prefixo bond, e assim deve ser identificada como bond0, bond1 e assim por diante. Para criar um enlace agregado no Netkit basta declarar em um switch uma interface desse tipo. A sintaxe da declaração é praticamente idêntica a de interfaces ethernet, como se pode ver abaixo: pc1[type]=generic
pc2[type]=generic
sw1[type]=switch
sw2[type]=switch
pc1[eth0]=sw1-port0:ip=192.168.0.1/24
pc2[eth0]=sw2-port0:ip=192.168.0.2/24
sw1[eth0]=sw1-port0
sw2[eth0]=sw2-port0
# Define em cada switch uma interface bond0 que agrega dois enlaces.
# O enlace agregado deve ser composto por uma ou mais interfaces ethernet.
# O nome do enlace agregado é sw1-sw2 no exemplo.
sw1[bond0]=sw1-sw2:interfaces=eth1,eth2:mode=8023ad
sw2[bond0]=sw1-sw2:interfaces=eth1,eth2:mode=8023ad
Nesse exemplo o enlace agregado foi criado entre os switches sw1 e sw2. Como se pode notar, existe uma opção de configuração adicional interfaces, usada para listar as interfaces ethernet a serem agrupadas. Essas interfaces não devem ser declaradas explicitamente. Além disso, não se podem configurar VLANs na interface agregada (bond0 no exemplo). Por fim, mais de um enlace agregado pode ser criado no mesmo switch, bastando identificá-los por interfaces bond diferentes (bond1, bond2, ...). O exemplo acima cria a seguinte rede:
Máquinas com suporte a PPPoEA configuração de uma infraestrutura de acesso baseada em PPPoE implica o ajuste de vários detalhes tanto nos clientes quanto no AC (servidor PPPoE). Muitos desses detalhes podem ser abreviados explorando-se opções existentes no Netkit. Na configuração do Netkit um AC PPPoE deve ser uma máquina virtual do tipo pppoe, que é uma extensão do tipo gateway. Desta forma, todas as capacidades apresentadas por gateway estão presentes no tipo pppoe. Já as opções necessárias para o funcionamento de um AC devem ser especificadas usando-se o atributo pppoe. O cliente PPPoE, por sua vez, precisa apenas indicar em que interface ethernet será iniciado o enlace PPPoE. O exemplo abaixo mostra uma pequena rede com um AC e dois clientes: sw1[type]=switch
sw2[type]=switch
ac[type]=pppoe
cliente1[type]=generic
cliente2[type]=generic
servidor[type]=generic
# define as opções do AC PPPoE
ac[pppoe]=nome_ac:interface=eth0:users=aluno1/blabla,aluno2/rruahhh:range=172.18.1.1,172.18.1.10:ip=172.18.1.20
sw1[eth0]=sw1-port0
sw1[eth1]=sw1-port1
sw1[eth2]=sw1-port2
sw2[eth0]=sw2-port0
sw2[eth1]=sw2-port1
ac[eth0]=sw1-port0
ac[eth1]=sw2-port0:ip=192.168.0.1/24
servidor[eth0]=sw2-port1:ip=192.168.0.10/24
# Define que a interface eth0 de cliente1 e cliente2 devem operar em modo PPPoE.
cliente1[eth0]=sw1-port1
cliente1[ppp0]=nome_ac:type=pppoe:user=aluno1:password=blabla:interface=eth0
cliente2[eth0]=sw1-port2
cliente2[ppp0]=nome_ac:type=pppoe:user=aluno2:password=rrruahh:interface=eth0
A configuração acima gera uma rede com dois computadores clientes, um AC PPPoE e um servidor, como mostrado na seguinte figura:
# define as opções do AC PPPoE
ac[pppoe]=nome_ac:interface=eth0:users=aluno1/blabla,aluno2/rruahhh:range=172.18.1.1,172.18.1.10:ip=172.18.1.20
A primeira opção mostrada acima (nome_ac) corresponde ao nome do AC, usado durante a etapa de descoberta PPPoE feita pelos clientes. As demais opções do AC são:
Um cliente precisa definir uma interface PPP que deve operar em modo PPPoE, informando sobre qual interface ethernet ela deve operar. Além disso, devem ser especificadas as opções PPPoE, como destacado abaixo: # A interface eth0 deve existir para que possa criar a interface ppp0
cliente1[eth0]=sw1-port1
# Aqui se declara a interface ppp0 em modo PPPoE
cliente1[ppp0]=nome_ac:type=pppoe:user=aluno1:password=blabla:interface=eth0
As opções PPPoE do cliente são:
Uma vez estabelecido um enlace PPPoE, é criada automaticamente uma rota default no cliente usando o AC como gateway. RoteadoresRoteadores podem ser criados no Netkit usando máquinas virtuais do tipo router. Um roteador tem sua função de gateway ativada automaticamente, e executa o programa Quagga, que implementa protocolos de roteamento (tais como OSPF, RIP e BGP). O exemplo abaixo mostra a criação de uma pequena rede com dois roteadores interligados por um link PPP. r1[type]=router
r2[type]=router
pc1[type]=generic
pc2[type]=generic
r1[ppp0]=link0:ip=10.0.0.1/30
r1[eth0]=lan0:ip=192.168.0.254/24
r1[route]=default:dev=ppp0
r2[ppp0]=link0:ip=10.0.0.2/30
r2[eth0]=lan1:ip=192.168.1.254/24
r2[route]=default:dev=ppp0
pc1[eth0]=lan0:ip=192.168.0.1/24
pc1[default_gateway]=192.168.0.254
pc2[eth0]=lan1:ip=192.168.1.2/24
pc2[default_gateway]=192.168.1.254
Ativação de protocolos de roteamentoA ativação de protocolos de roteamento pode ser feita automaticamente no arquivo de configuração. As configurações de cada protocolo de roteamento residem em arquivos contidos no subdiretório /etc/quagga, os quais estão inicialmente vazios. Após iniciar a rede virtual pode-se usar o console do roteador para configurá-lo, e então executar o comando write memory para gravar sua configuração. Recomenda-se definir o atributo preserve na máquinas virtuais do tipo roteador, de forma a preservar as configurações desses protocolos (lembre de usar o menu File -> Export APÓS encerrar a execução da rede virtual, como já explicado). # Ativa os protocolos RIP e OSPF no roteador r1
r1[router]=rip,ospf
# Preserva as configurações do roteador r1
r1[preserve]=/etc/quagga
Os protocolos de roteamento que podem ser ativados são:
Switches MPLSMPLS é uma tecnologia para redes WAN que usa o conceito de circuitos virtuais (chamados no MPLS de LSP - Label Switched Path). Existe um projeto no Linux para implementar parte da funcionalidade MPLS, o qual está disponível nas máquinas virtuais do Netkit. Apesar desse projeto estar incompleto, algumas funcionalidades básicas podem ser experimentadas, tais como criação de LSP estáticos e túneis MPLS. No entanto, ainda não é possível criar VPNs MPLS (chamadas de VPLS) ou estabelecer LSP dinâmicos. Assim, no Netkit podem-se criar experimentos explorando essas funções elementares do MPLS. Um equipamento que comuta rótulos, ou switch MPLS, pode ser criado usando uma máquina virtual do tipo mpls. Em cada switch MPLS devem-se configurar:
Assim, um switch MPLS precisa usualmente ter configuradas essas quatro informações. A configuração do Netkit mostrada abaixo cria umapequena rede com dois switches MPLS e dois computadores comuns. sw1[type]=mpls
sw2[type]=mpls
h1[type]=generic
h2[type]=generic
# FEC: mapeia subrede destino para nhlfe
sw1[fec]=192.168.1.0/24:nhlfe=1
sw2[fec]=192.168.0.0/24:nhlfe=1
# NHLFE: como encaminhar uma PDU MPLS
sw1[nhlfe]=1:interface=eth0:label=100:ip=10.0.0.2
sw2[nhlfe]=1:interface=eth0:label=200:ip=10.0.0.1
# ILM: como identificar PDUs MPLS recebidas
sw1[ilm]=200:labelspace=0
sw2[ilm]=100:labelspace=0
# Labelspace: os mapeamentos de labelspaces a interfaces
sw1[labelspace]=0:interfaces=eth0
sw2[labelspace]=0:interfaces=eth0
sw1[eth1]=lan0:ip=192.168.0.254/24
sw1[eth0]=link1:ip=10.0.0.1/24
sw2[eth0]=link1:ip=10.0.0.2/24
sw2[eth1]=lan1:ip=192.168.1.254/24
h1[eth0]=lan0:ip=192.168.0.1/24
h2[eth0]=lan1:ip=192.168.1.1/24
h1[default_gateway]=192.168.0.254
h2[default_gateway]=192.168.1.254
Para configurar cada ítem do switch MPLS devem-se usar alguns atributos:
Qualquer um desses atributos pode ser especificado múltiplas vezes, como exemplificado abaixo: sw1[nhlfe]=1:interface=eth0:label=100:ip=192.168.0.2
sw1[nhlfe]=2:label=1000:nhlfe=1
A configuração acima irá adicionar duas NHLFE em sw1. Um exemplo de uma rede um pouco maior contém três switches MPLS: sw1[type]=mpls
sw2[type]=mpls
sw3[type]=mpls
h1[type]=generic
h2[type]=generic
h3[type]=generic
# FEC: mapeia subrede/mask para nhlfe
sw1[fec]=192.168.1.0/24:nhlfe=1
sw1[fec]=192.168.2.0/24:nhlfe=2
sw2[fec]=192.168.0.0/24:nhlfe=1
sw2[fec]=192.168.2.0/24:nhlfe=2
sw3[fec]=192.168.0.0/24:nhlfe=1
sw3[fec]=192.168.1.0/24:nhlfe=2
# NHLFE: como encaminhar uma PDU MPLS ... (push)
sw1[nhlfe]=1:interface=eth0:label=110:ip=10.0.0.2
sw1[nhlfe]=2:interface=eth0:label=120:ip=10.0.0.2
sw2[nhlfe]=1:interface=eth0:label=210:ip=10.0.0.1
sw2[nhlfe]=2:interface=eth1:label=220:ip=10.0.2.3
sw2[nhlfe]=3:interface=eth1:label=130:ip=10.0.2.3
sw3[nhlfe]=1:interface=eth0:label=310:ip=10.0.1.1
sw3[nhlfe]=2:interface=eth1:label=320:ip=10.0.2.2
# ILM: como identificar PDUs MPLS recebidas (implicitamente faz um pop)
sw1[ilm]=210:labelspace=0
sw1[ilm]=310:labelspace=0
sw2[ilm]=110:labelspace=0
sw2[ilm]=120:labelspace=0:nhlfe=3
sw2[ilm]=320:labelspace=0
sw3[ilm]=130:labelspace=0
sw3[ilm]=220:labelspace=0
# Labelspace: os mapeamentos de labelspaces a interfaces
sw1[labelspace]=0:interfaces=eth0,eth1
sw2[labelspace]=0:interfaces=eth0,eth1
sw3[labelspace]=0:interfaces=eth0,eth1
sw1[eth0]=link1:ip=10.0.0.1/24
sw1[eth1]=link2:ip=10.0.1.1/24
sw1[eth2]=lan0:ip=192.168.0.254/24
sw2[eth0]=link1:ip=10.0.0.2/24
sw2[eth1]=link3:ip=10.0.2.2/24
sw2[eth2]=lan1:ip=192.168.1.254/24
sw3[eth0]=link2:ip=10.0.1.3/24
sw3[eth1]=link3:ip=10.0.2.3/24
sw3[eth2]=lan2:ip=192.168.2.254/24
h1[eth0]=lan0:ip=192.168.0.1/24
h2[eth0]=lan1:ip=192.168.1.1/24
h3[eth0]=lan2:ip=192.168.2.1/24
h1[default_gateway]=192.168.0.254
h2[default_gateway]=192.168.1.254
h3[default_gateway]=192.168.2.254
Opções e configurações avançadasPreferênciasAtributos globais definem parâmetros válidos para o experimento como um todo. Esses atributos devem ser especificados com a sintaxe global[nome_do_atributo]=valor_do_atributo. No momento há apenas o atributo path, que define o diretório onde devem ser criados os arquivos temporários e discos virtuais do experimento. O diretório de trabalho pode ser especificado com um caminho relativo, como exemplificado abaixo: # o diretório de trabalho do experimento será o subdiretório "tmp" dentro do diretório onde
# está o arquivo de configuração (i.e. diretorio_do_arquivo_de_configuracao/tmp)
global[path]=tmp
... ou um caminho absoluto: # o diretório de trabalho do experimento será o subdiretório "/home/aluno/tmp".
global[path]=/home/aluno/tmp
Se o atributo global path não for definido, o netkit2 irá criar um subdiretório dentro do diretório onde está o arquivo de configuração, e usá-lo como diretório de trabalho. O nome desse subdiretório será da forma tmp-xxxxx, sendo xxxxx um número aleatório. ProjetosModo de instalação de softwareUma biblioteca de exemplos de experimentosPara facilitar o aprendizado de como usar o Netkit foi criada uma pequena coleção de experimentos. Experimentos com LANs
Experimentos com VLANObservar os quadros com tag nas interfaces que operam em modo tagged. Teste também o isolamento entre VLANs.
Leia os arquivos de inicialização switch1.startup, switch2.startup e pc4.startup para entender como foram configuradas as VLANs. API do NetkitO Netkit possui uma API para iniciar e parar experimentos, entre outras coisas. Ela está implementada no módulo ${NETKIT2_HOME}/bin/netkit.py, mas não deve ser usada diretamente. Para usá-la é recomendável usar NetkitParser, uma classe que interpreta arquivos de configuração e a partir deles cria objetos Network. A classe Network representa uma rede virtual do Netkit, e com ela se pode inciar, parar, ou mudar preferências. O exemplo abaixo mostra como usar a classe NetkitParser e o objeto Network obtido por meio dela: import nkparser
# Cria o parser, informando o arquivo de configuração a ser interpretado
parser = nkparser.NetkitParser('teste.conf')
# Interpreta o arquivo de configuração
parser.parse()
# Obtém um objeto Network que representa a rede descrita no arquivo de configuração
rede = parser.get_network()
# Executa a rede. Cada VM terá sua console vinculada a um xterm
rede.start()
# Cria um experimento Netkit
parser = nkparser.NetkitParser('teste.conf')
parser.parse()
rede = parser.get_network()
# Cria um gerador de terminais
pool = TermPool()
# Inicia o experimento usando o gerador de terminais
rede.start(pool)
# Inicia todos os terminais e, consequentemente, todas as VM do experimento
pool.start()
# Obtém o terminal da VM pc1
term = pool.get_term('pc1')
# Através do objeto term se pode conversar com a console da VM pc1 ...
term.write('poweroff\n')
Classe NetkitParserDefinida em nkparser.py
parse(): interpreta o arquivo de configuração. Erros de sintaxe causam exceções do tipo ParseError, e erros semânticos (ex: uso de uma VM não declarada) disparam exceções do tipo SemanticError. Essas exceções informam sobre a localização do erro dentro do arquivo de configuração. get_network(): obtém um objeto Network que representa a rede descrita no arquivo de configuração. Esse método somente pode ser chamado após o arquivo ter sido interpretado (i.e. após parse()). update_prefs(prefs): modifica as preferências da rede de forma permanente, acrescentando-as ao arquivo de configuração. tokenize(): faz a análise léxica do arquivo de configuração, retornando uma lista com todos os tokens encontrados. Classe ParseErrorA classe ParseError especializa a classe Exception para representar erros na análise léxica ou sintática de um arquivo de configuração. Uma exceção ParseError possui os seguintes atributos:
Classe SemanticErrorA classe SemanticError especializa a classe Exception para representar erros na análise semântica de um arquivo de configuração. Uma exceção SemanticError possui os seguintes atributos:
Classe NetworkDefinida em netkit.py
Classe VMDefinida em uml_layer.py
interface TermPoolDefinido pelo software que usa a API do Netkit. O TermPool default está em uml_layer.py
Métodos:
class TermPool:
def __init__(self):
self.terms = {}
def addVM(self, name, cmd):
self.terms[name] = NetTerm(name, cmd)
def start(self):
for vm in self.terms:
self.terms[vm].start()
def stop(self):
for vm in self.terms:
self.terms[vm].stop()
def get_term(self, name):
return self.terms[name]
def get_terms(self):
return self.terms
interface TerminalOBS: Deve-se implementar uma classe que realize esta interface, a qual é necessária para TermPool.
class NetTerm:
def __init__(self, vm):
self.name = vm.get_name()
self.fd = -1
def start(self):
pass
def stop(self):
pass
API RESTfulA API RESTful foi concebida como uma interface entre clientes remotos e o Netkit. Essa API deve ser implementada por um controlador de instâncias do Netkit, o qual deve ser capaz de traduzir as operações da API para ações sobre redes virtuais do Netkit. Essa interface ainda está em desenvolvimento, e faz parte do TCC de Ricardo Martins (2013-2 a 2014-1).
|
16/05/2018: Instalando Kodi
Aula 26 |
---|
Instalação do centro de midiaNesta aula iremos efetuar a instalação de um software que será utilizado como centro de mídia, o Kodi. Muitos softwares existem, dentre eles Kodi, Miro, Universal Media Server e Plex (devem existir ainda outros ...). Instalando o KodiPara a instalação do Kodi, iremos seguir os passos do site HOW-TO:Install Kodi for Linux: sudo apt-get install software-properties-common sudo add-apt-repository ppa:team-xbmc/ppa sudo apt-get update sudo apt-get install kodi Apesar do guia acima parecer curto e fácil, ele implica alguns conhecimentos para ser realizado a contento - e entendido ! Uma compreensão sobre o que é o sistema operacional Linux, quais seus elementos básicos, e como ele pode ser utilizado, são necessários para essa tarefa. Mas veremos isso à medida que instalarmos o Kodi. Após a instalação, devemos efetuar alguns ajustes no Kodi, tais como o idioma, local dos arquivos, entre outros. Os links abaixo irão auxiliar neste processo:
|
17/05/2018: Conceitos gerais VOIP, preparação do servidor e instalação do Asterisk e banco de dados
Aula 27 |
---|
Telefonia IP ou VoIP: O que é? A Comunicação de Voz em Redes IP, chamada de VoIP, consiste no uso das redes de dados que utilizam o conjunto de protocolos das redes IP (TCP/UDP/IP) para a transmissão de sinais de Voz em tempo real na forma de pacotes de dados. A sua evolução natural levou ao aparecimento da Telefonia IP, que consiste no fornecimento de serviços de telefonia utilizando a rede IP para o estabelecimento de chamadas e comunicação de Voz. Nessas redes são implementados protocolos adicionais de sinalização de chamadas e transporte de Voz que permitem a comunicação com qualidade próxima àquela fornecida pelas redes convencionais dos sistemas públicos de telefonia comutada ou de telefonia móvel. Digitalização de Sinais de Voz Nos sistemas tradicionais o sinal de Voz utiliza uma banda de 4 kHz, e é digitalizado com uma taxa de amostragem de 8 kHz para ser recuperado adequadamente (Princípio de Nyquist). Como cada amostra é representada por um byte (8 bits, com até 256 valores distintos), cada canal de Voz necessita de uma banda de 64 kbit/s (8.000 amostras x 8 bits). Esta forma de digitalização do sinal de Voz atende a recomendação ITU-T G.711 - Pulse code modulation (PCM) of voice frequencies. Nos sistema de transmissão de Voz sobre IP, onde a demanda por banda é crítica, torna-se necessário utilizar também algoritmos de compressão do sinal de Voz. Esses algoritmos têm papel relevante pela economia de banda que proporcionam. O seu uso tem sido possível graças ao desenvolvimento dos processadores de sinais digitais (DSP’s), cuja capacidade de processamento tem crescido vertiginosamente. Estas necessidades incentivaram o desenvolvimento de tecnologias mais complexas para a digitalização e compressão de Voz, e que foram registradas através de recomendações do ITU-T. Estas recomendações são apresentadas na tabela abaixo, com algumas características relevantes. Asterisk O Asterisk é a implementação de uma central telefônica PBX (Private Branch eXchange) em software, criado por Mark Spencer em 1999, e distribuído pela Digium livremente seguindo a licençaGPL (GNU General Public License – GPL), ou através de código proprietário. O nome Asterisk vem do símbolo ‘*’, muito comum no mundo da telefonia. O Asterisk foi originalmente desenvolvido para Linux, mas atualmente podeser instalado e executado em uma grande variedade de sistemas operacionais, incluindo NetBSD, OpenBSD, FreeBSD, Mac OS X, Solaris e até mesmo Microsoft Windows, onde é conhecido por Asterisk Win32. Características do Asterisk O Asterisk é um software, baseado na licença GPL (GNU General Public License), que executa todas as funções de uma central telefônica convencional através das principais tecnologias de comunicação existentes no mercado, como por exemplo: linhas telefônicas analógicas, links de telefonia digital via placas de comunicação TDM (Time-Division Multplexing, ou Multiplexaçã ,o por divisão detempo), VoIP (Voice over IP, ou Voz sobre IP) através dos protocolos SIP, H.323, IAX2, MGCP, Skinny,GoogleTalk, Skype, entre outros. Através do Asterisk é possível estabelecer uma chamada entre qualquer um desses protocolos. O Asterisk é o que chamamos de B2B User Agent, ou melhor, Back-to-Back User Agent, ele estabelece uma chamada telefônica, separando cada “perna” da chamada entre origem e destino, e monitora todo o tráfego de áudio entre esses pontos. Por isso, caso esses pontos estejam utilizando CODECs diferentes, o Asterisk consegue transcodificar o áudio sem qualquer problema. Pode-se dizer que o Asterisk possui todas as funcionalidades das chamadas centrais telefônicas convencionais, como URAs, correio de voz, conferência, distribuição automática de chamadas, entre outras, e caso seja necessário, é possível acrescentar novas funcionalidades ao sistema através do próprio plano de discagem do Asterisk, módulos customizados escritos em C, ou ainda através de scripts escritos em Asterisk Gateway Interface (AGI). *Fonte: Construindo um PBX IP na pratica (Alexandre Keller) Codecs Um dos componentes necessários para transmissão de voz numa rede de dados é o Áudio CODEC (Codificador-Decodificador). Este componente é o responsável por transformar a voz humana (um sinal analógico) em uma seqüência de bits (um sinal digital) para transmissão numa rede de dados, fazendo amostragens periódicas no sinal de voz. Em equipamentos do tipo gateways VoIP, esses CODECs são implementados através de um componente chamado DSP (Digital Signal Processor). A introdução dos microprocessadores no final dos anos 70 e início dos anos 80 tornou possível usar técnicas de processamento digital de sinais (Digital Signal Processing) em um range muito maior de aplicações. Durante os anos 80 a importância crescente do processamento digital de sinais levou vários fabricantes importantes (como Texas Instruments, Analog Devices e Motorola) a desenvolverem os chips DSP, ou seja, microprocessadores especializados com arquiteturas projetadas especificamente para os tipos de operações requeridas ao processamento digital de sinais. Como um microprocessador de uso geral, um DSP é um dispositivo programável, com seu próprio conjunto de instruções nativas. O uso desses chips associados a algoritmos de compressão permitiu a implementação de diversas tecnologias de CODEC’s. Exemplos de chips DSP são o DSP542 e DSP549 fabricados pela Texas Instruments e usados pela CISCO Systems em seus gateways VoIP [CISCO-CODEC1]. Cada CODEC provê certa qualidade de voz. A medida de qualidade da voz transmitida é uma resposta subjetiva de um ouvinte. Uma medida comum usada para determinar a qualidade do som produzido pelos CODECs específicos é o MOS (Mean Opinion Score). Com o uso do MOS, um amplo range de ouvintes julgam a qualidade de uma amostra de voz (correspondendo a um CODEC particular) numa escala de 1 a 5. A partir desses resultados, é calculada a média dos scores para atribuir o MOS para aquela amostra [CISCO-CODEC2]. Na tabela 1 são apresentados alguns scores MOS para os CODECs mais usados. Na Tabela 2 são descritos os scores MOS.
Neste semestre iremos trabalhar com o Asterisk versão 11.1.1, o LibPRI 1.4, que é uma biblioteca Libpri será instalada para que tenhamos suporte aos canais PRI( ISDN, E1, T1 ), e o DAHDI, que é um pacote (Digium Asterisk Hardware Device Interface) nos permite carregar os drivers e configurar diversos tipos de placas de telefonia (para conectar telefones analógicos, linhas telefônicas, linhas digitais e outros). Antes de qualquer coisa, devemos atualizar o sistema via console de comando: #apt-get update #apt-get upgrade Também devemos instalar algumas dependências: # apt-get install -y make wget libssl-dev ncurses-dev libnewt-dev libxml2-dev linux-headers-generic g++ libsqlite3-dev # apt-get install -y mysql-server libmysqld-dev Para baixar os arquivos do Asterisk, DAHDI e LibPRI, seguem os links abaixo: Asterisk 11.1.1 Campos para o banco de dados:
|
23/05/2018: Comandos e configurações do Asterisk. Criação de ramais
Aula 28 |
---|
Comandos Asterisk Para iniciarmos a utilização do Asterisk, devemos conhecer alguns comandos que serão utilizados no decorrer da disciplina.
sip set debug on sip reload: Reload No arquivo: sip.conf
iax2 set debug on iax2 show channels: Visualizar canais ativos do Tipo IAX
Preparar o servidor para liberar portas
Iniciando a configuração dos ramais
Context: Configura o contexto padrão onde todos os clientes serão colocados, a menos que seja sobrescrito na definição da entidade. Allow: Permite que um determinado codec seja usado. Disallow: Proíbe um determinado codec. Bindport: Porta que o Asterisk deve esperar por conexões de entrada SIP. O padrão é 5060. maxexpirey: Tempo máximo para registro em segundos. Defaultexpirey: Tempo padrão para registro em segundos.
[name]: Quando um dispositivo SIP conecta-se ao Asterisk, ele utiliza a parte username do SIP URI para encontrar o peer/user. Type: Configura a classe de conexão, as opções são peer, user e friend. Peer: Entidade para a qual o Asterisk envia chamadas. User: Entidade que faz chamadas através do Asterisk. Friend: Os dois ao mesmo tempo. Host: Configura o endereço IP ou o nome do host. Pode-se usar também a opção ‘dynamic’ onde se espera que o host faça o registro, é a opção mais comum. Secret: Senha usada para autenticar o peer ou user fazendo uma chamada. Qualify: caso esteja yes, o asterisk enviará um comando regularmente para verificar se o dispositivo ainda está online.
Plano de discagem O plano de discagem é um conjunto de instruções. A extensão executa uma ação quando uma chamada é efetuada. Sintaxe de um comando extension:
[general]
static e writeprotect – permite salvar o plano de discagem a partir da linha de comando. Também devemos criar um contexto que já foi pré definido no ramal criado. No nosso caso se chamará default:
As aplicações mais comuns no Asterisk são:
Crie também um plano de discagem que permita a ligação entre todos os ramais.
|
24/05/2018 a 01/06/2018: Aulas suspensas
Aulas suspensas |
---|
Aulas suspensas devido a greve dos caminhoneiros
|
06/06/2018: Plano de discagem e máscaras
Aula 29 |
---|
Plano de discagemO plano de discagem define como o Asterisk irá gerenciar as chamadas. Ele consiste de uma lista de instruções ou passos que o Asterisk deveria seguir. Essas instruções são disparadas a partir dos dígitos recebidos de um canal ou aplicação. O extensions.conf pode ser separado em quatro partes:
ContextosOs contextos definem o escopo e permitem separar diferentes partes do plano de discagem, recebem o seu nome dentro de chaves ([]). No início do arquivo extensions.conf existe um contexto chamado [globals] onde as variáveis globais são definidas e podem ser usadas por todo o plano de discagem. E o contexto [general] que é utilizado para definir alguns parâmetros gerais. Os contextos estão ligados diretamente aos canais. Quando uma ligação entra no Asterisk por um canal ela é processada dentro do contexto deste canal. Ex: [gerentes] [visitantes]
ExtensõesO plano de discagem é um conjunto de instruções. A extensão executa uma ação quando uma chamada é efetuada. Sintaxe de um comando extension: exten=> number (name), {priority|label{+|-}offset}[(alias)],application Exemplo: exten => 9001,1,Dial(SIP/9001,20) ; Extensão 9001, prioridade 1, disca para o ramal 9001 pelo protocolo SIP, tempo de resposta em segundos. Dentro de uma extensão, podemos ter as chamadas variáveis de canal, como abaixo: exten =>2001,2,DIAL(SIP/${RAMAL}) Neste exemplo acima, criamos a variável “RAMAL” em tempo de execução, ou seja, na criação do Canal, ou da chamada. As variáveis de canais são as mais utilizadas normalmente, para trazer informação dos canais normalmente, como nome do canal , nome do contexto, extensão, etc. Vejamos abaixo algumas das variáveis mais usadas: ${CALLERID} Identificador da chamada (nome ou número)
exten => _20XX,1,Dial(SIP/${EXTEN})
Aplicações básicas do AsteriskAnswer – Atende uma chamada. Para verificar as aplicações no asterisk, basta digitar n cli do mesmo o seguinte comando: # ubuntu-server*cli> core show applications Caso queira uma explicação detalhada de uma aplicação, utilize o comando: # ubuntu-server*cli> core show application nome_da_aplicacao Onde o termo nome_da_aplicacao corresponde a aplicação a qual queremos os detalhes.
8000 – numérica Máscaras _ - início de uma máscaras Prioridades Prioridades são passos numerados na execução de cada extensão. Cada prioridade chama uma aplicação especifica. Se os números das prioridades não forem sequenciais o Asterisk aborta a execução. A partir da versão 1.2 do Asterisk, tornou-se comum o uso da prioridade “n”, no lugar da associação manual de números, assim como a possibilidade da utilização de labels e aliases.
Leituras que podem ser úteis:
IMPORTANTE
13/06/2018 - Início do desenvolvimento do projeto final. 28/06/2018 - Última data para apresentação do projeto final. 04/07/2018 - Prova de Recuperação.
|
13/06/2018: Definindo Projeto Final
Aula 30 |
---|
IMPORTANTE
Todas as configurações/orientações abaixo deverão ser efetuadas no computador de cada integrante do grupo.
|