Curso de CVS - Lab 2

Administração do CVS: Laboratório do Aluno Copyright® 2005, Marden Neubert

1

Lab2-1: Instalando o CVS

Objetivos

Ao final deste lab, você será capaz de: • Compilar uma distribuição-fonte do CVS no Linux. • Instalar uma distribuição binária do CVS no Linux. • Instalar uma distribuição binária do CVS no Windows. • Testar instalações locais e remotas do CVS.

Cenário

Neste lab, instalaremos o CVS no Linux e no Windows. Testaremos então as instalações, realizando o acesso cliente-servidor, explorando as diferentes combinações de cliente e servidor.

Tarefa 1: Compilar a distribuição-fonte do GNU CVS no Linux

1. Entre no Linux como root. 2. Copie o arquivo cvs-1.11.21.tar.bz2, incluído nos materiais do aluno para o diretório /usr/src.

a. Opcionalmente, pegue-o assim: wget http://ftp.gnu.org/non-gnu/cvs/source/stable/1.11.21/cvs-1.11.21.tar.bz2

3. Descompacte esse arquivo. tar –xjf cvs-1.11.21.tar.bz2

4. Entre no diretório cvs-1.11.21. 5. Execute o script de configuração da compilação.

./configure O comando inspecionará o ambiente e criará os scripts de compilação.

Dica: As instruções para a instalação (binários e fontes) nas diversas plataformas suportadas encontram-se no arquivo INSTALL. Execute ./configure --help para verificar as diversas opções oferecidas.

6. Realize a compilação. make O código-fonte será compilado, gerando os executáveis.

7. Entre no diretório src e verifique que lá se encontra o executável do CVS, o arquivo cvs. 8. Execute esse arquivo para verificar a versão da distribuição.

./cvs –v A saída deve ser similar a:


2

9. Não iremos instalar essa versão, pois instalaremos a distribuição binária. Caso você queira instalar essa distribuição-fonte, basta digitar make install.

Tarefa 2: Instalar a distribuição binária do GNU CVS no Linux

1. Entre no Linux como root. 2. Execute apt-get update, para atualizar o cache de pacotes instalados. Certifique-se que mídias

removíveis usadas na instalação encontram-se disponíveis. 3. Execute apt-get install cvs. Se a versão mais recente do CVS já tiver sido instalada, o que é

provável em distribuições de Linux recentes, será exibida uma mensagem similar a:

4. Teste se o executável do CVS está no PATH e qual a versão: cvs –v. Caso o executável não seja encontrado, configure seu PATH para incluí-lo.

Tarefa 3: Instalar a distribuição binária do CVSNT no Windows

1. Entre no Windows como um usuário do grupo dos Administradores. 2. Execute o arquivo cvsnt-2.5.02.2115.msi, incluído nos materiais do aluno. Um guia conduzirá o

processo de instalação, como mostrado abaixo.

3. Clique “Next”. A licença do CVSNT será exibida.


3

4. Selecione “I accept…” e clique “Next”. As opções de instalação serão exibidas.

5. Clique na opção “Custom”, para verificarmos o que está sendo instalado. A seguinte tela é exibida.


4

6. Verifique que as duas opções não selecionadas para instalação são o protocolo “Fork” e “RCS Wrappers”. Essas opções podem ser deixadas desmarcadas. Clique “Next”. A instalação estará pronta para ser iniciada

7. A instalação será feita e, ao final, a seguinte mensagem será exibida. Clique “Finish” para terminar a instalação.


5

8. O instalador pedirá para que você reinicie seu computador. Aceite.

5. Ao retornar, teste se o executável do CVS está no PATH e qual a versão: cvs –v. Caso o executável não seja encontrado, configure seu PATH para incluí-lo.

Tarefa 4: Testar a instalação do servidor

1. Na linha de comando, execute: cvs –d :pserver:login@servidor:/var/lib/cvs onde login é o nome de usuário para o teste e servidor é o endereço do servidor CVS, ambos a serem fornecidos pelo instrutor.

2. Observe a saída. Ela deve mostrar tanto a versão instalada no cliente quanto a instalada no servidor.


6

Lab2-2: Criando um Repositório

Objetivos

Ao final deste lab, você será capaz de: • Criar um repositório no CVS. • Conhecer a estrutura de um repositório. • Conhecer o formato de um arquivo de histórico. • Saber como uma alteração afeta um arquivo de histórico.

Cenário

Neste lab, criaremos um repositório CVS usando o comando init. Veremos também como configurar adequadamente um repositório já existente em uma instalação Linux. Em seguida, faremos um check-out do diretório CVSROOT e, na cópia de trabalho, alteraremos o arquivo modules, que define módulos no repositório, incluindo apenas um comentário. Faremos então um check-in da alteração e veremos como o histórico do arquivo se comporta.

Tarefa 1: Criar um novo repositório CVS (Linux)

Mesmo que muitas instalações Linux já tragam o CVS instalado e um repositório criado, é importante exercitarmos a criação de um novo repositório. 1. Entre no Linux como root. 2. Crie um usuário cvs, dentro de um grupo cvs. Todos os usuários que utilizarão o CVS devem

pertencer a este grupo. groupadd cvs

useradd –c “Dono do CVS” –G cvs cvs

mkdir /home/cvs

chown cvs:cvs /home/cvs

passwd cvs Use como senha cvsr00t

3. Crie um diretório para a raiz do repositório. Este passo pode ser pulado, pois a própria chamada a init cria esse diretório. Entretanto, é mais simples criar a raiz manualmente para se configurar suas permissões corretamente. mkdir /var/lib/cvsroot O diretório /var/lib/cvsroot é recomendado pelo Filesystem Hierarchy Standard (http://www.pathname.com/fhs) como localização do repositório CVS.

4. Torne o usuário cvs dono do repositório. chown cvs:cvs /var/lib/cvsroot

5. Mude o bit SGID da raiz do repositório, para que os arquivos criados no diretório tenham o mesmo ID de grupo que a raiz. Também dê ao grupo permissões de escrita, leitura e execução sobre o diretório. chmod g+srwx /var/lib/cvsroot

6. Crie um novo shell como o usuário cvs. su – cvs Ou entre em outro terminal fornecendo o login cvs e a senha definida..

7. Crie o repositório sobre a raiz preparada anteriormente. cvs –d /var/lib/cvsroot init

8. Verifique que todos os arquivos no repositório têm cvs como dono e cvs como grupo. ls –laR /var/lib/cvsroot | less


7

Tarefa 2: Configurar e examinar um repositório existente (Linux)

Como provavelmente sua nova instalação de Linux trará um repositório existente, veremos também como configura-lo para evitar problemas com acessos e permissões. Também examinaremos os arquivos presentes nele, para entendermos melhor seu funcionamento e um pouco do formato RCS. 1. Entre no Linux como root. 2. Liste recursivamente todos os arquivos sob /var/lib/cvs. Neste diretório, a maioria das

distribuições Linux traz um repositório já instalado. ls –laR /var/lib/cvs | less Observe que os arquivos são de propriedade de root, grupo src.

3. Altere todos os arquivos do repositório para propriedade do usuário cvs, grupo cvs. chown –R cvs:cvs /var/lib/cvs

4. Mude o bit SGID da raiz do repositório. chmod g+srwx /var/lib/cvs

5. Entre no diretório /var/lib/cvs e veja que o único elemento dentro dele é o diretório CVSROOT. Este é o diretório de controle do CVS, chamado também de diretório administrativo. Nele ficam os arquivos que controlam o comportamento do servidor CVS.

6. Entre em CVSROOT e verifique os arquivos que nele se encontram. Liste todos os arquivos, inclusive os escondidos. ls –la

7. Observe que existem 3 “tipos” de arquivo em CVSROOT. Para cada nome de arquivo, por exemplo, modules, temos os arquivos modules, modules,v e .#modules. Deixemos este último de lado por enquanto.

8. Examine o conteúdo do arquivo modules. less modules Observe que ele é um arquivo de controle do repositório. Ele e os demais arquivos presentes em CVSROOT são os chamados “arquivos administrativos”. O papel do arquivo modules é especificar os módulos presentes no repositório. Note que ele contém apenas comentários, que são as linhas iniciadas por “#”.

9. Examine o conteúdo do arquivo modules,v. less modules,v Observe que esse arquivo contém informações de controle, tais como head, date, entre outras e, ao final, uma seção chamada text, seguida de “@” e o conteúdo que vimos no arquivo modules. Ao final do arquivo, encontramos outro “@”. Este é o arquivo de histórico correspondente a modules. Os arquivos administrativos têm essa característica peculiar: enquanto módulos comuns têm somente os históricos armazenados no repositório, os arquivos sob CVSROOT têm também as cópias mais recentes armazenadas no mesmo local. Essas cópias são usadas para controlar o comportamento do servidor CVS.

Dica: Não entraremos em detalhes sobre o formato dos arquivos de histórico; isso só é necessário para quem deseja desenvolver sobre o código-fonte do CVS. Caso deseje mais informações sobre esse formato, veja o manual do formato RCS. man rcsfile

Tarefa 3: Alterar um arquivo administrativo e ver os resultados

Deixaremos de atuar por um momento como administradores de sistemas e passaremos a usuários do CVS. Alteraremos um arquivo administrativo e veremos os resultados no repositório. 1. Entre no Linux como root.


8

2. Escolha um nome de usuário para você e crie um usuário no Linux com esse nome. Por exemplo, o instrutor optou pelo nome mneubert. useradd –c “Meu usuario” –G cvs mneubert

mkdir /home/mneubert

chown mneubert:users /home/mneubert

passwd mneubert Use uma senha de sua preferência.

3. Entre em outro terminal com esse usuário e senha. 4. Crie logo abaixo de seu diretório home uma raiz para armazenar todas as suas áreas de trabalho,

em diferentes projetos. mkdir trabalho

5. Entre nesse diretório e faça um check-out do módulo CVSROOT. Como ele é um diretório que se encontra abaixo da raiz do repositório, ele se comporta de forma semelhante a um módulo (projeto). Há algumas diferenças, como veremos adiante. cvs –d /var/lib/cvs checkout CVSROOT

6. Observe a saída do comando. Após a execução, veja que foi criado um diretório chamado CVSROOT, como visto na figura abaixo.

7. Entre no diretório CVSROOT criado sob o diretório trabalho e edite o arquivo modules. Use seu editor de preferência. vim modules

8. Acrescente um comentário ao fim desse arquivo. Observe que linhas de comentário iniciam com o caractere “#”. Por exemplo, crie a seguinte linha: # Este comentário eh um teste

9. Faça o check-in dessa alteração. cvs commit –m “Teste: acrescentando um comentario” modules A saída do comando deve ser similar à figura abaixo.

10. Observe que há uma linha diferente do que vimos na saída do comando commit, quando fizemos um passeio pelo CVS (Módulo 1). A linha diz que o CVS está reconstruindo o banco de dados de arquivos administrativos. Essa é a diferença entre os arquivos administrativos (o diretório CVSROOT) e um módulo normal: existe uma cópia da revisão mais recente de cada arquivo no próprio repositório. O que o CVS fez quando imprimiu essa mensagem foi re-gerar esses arquivos (não só modules) após o check-in.


9

11. Confira que todos os arquivos administrativos foram re-gerados pelo commit, mas só o histórico de modules foi atualizado. ls –la /var/lib/cvs/CVSROOT | less A saída deve ter o seguinte trecho.

12. Note que o usuário que realizou o último commit permanece como dono do arquivo. Isso não é um problema, pois deixamos todos os subdiretórios de /var/lib/cvs com permissão de escrita para o grupo cvs. Novos diretórios serão criados assim também, pois marcamos o bit SGID da raiz. Observe também que todos os arquivos administrativos estão alterados pelo usuário mneubert, enquanto que, entre os históricos, somente modules,v está. Examine este arquivo e veja o que foi alterado. Note que o formato RCS é bastante compacto, tendo pouca redundância de informação.


10

Lab2-3: Importando Projetos

Objetivos

Ao final deste lab, você será capaz de: • Criar um projeto no CVS, importando arquivos existentes. • Criar um projeto vazio no CVS. • Importar uma nova distribuição de um conjunto de arquivos

já importados anteriormente. • Fazer uma alteração sobre um módulo e importar uma nova distribuição sobre as revisões

existentes, lidando com o conflito surgido. • Entender o funcionamento das opções de arquivos ignorados e filtrados.

Cenário

Neste lab, criaremos projetos usando o comando import. Veremos como esse comando se comporta quando realizamos uma importação sobre um módulo já existente, incluindo o caso em que esse módulo já foi alterado por alguma área de trabalho. Neste processo, veremos como funcionam as opções que configuram quais arquivos devem ser ignorados e filtrados.

Tarefa 1: Importar um novo projeto a partir de arquivos existentes

Normalmente o controle de versões não inicia no momento zero do projeto. Portanto, o cenário mais comum na criação de um projeto é partir de alguns arquivos existentes. Este lab usa apenas comandos CVS, não demandando acesso direto ao servidor. Portanto, ele pode ser executado tanto do Windows quanto do Linux. Como ainda não configuramos o CVS para acesso a repositórios remotos, é recomendável o uso de repositórios locais. 1. Entre no Windows ou no

Linux como um usuário normal. No Linux, você pode utilizar o usuário criado no Lab2-2 (no caso do instrutor, mneubert). O texto a seguir usará o Windows.

2. Extraia o arquivo places-

1.0-src.zip, encontrado no material do aluno, para um diretório, por exemplo, C:\Fontes\places-1.0-src. Este diretório não será uma área de trabalho, apenas um temporário para a importação dos fontes.


11

3. Entre no diretório criado pela extração e importe os arquivos para o repositório. Como ainda não configuramos repositórios remotos no CVS, use um repositório local. O caractere � indica que o comando continua na linha seguinte. C:\Fontes\places-1.0-src>cvs -d /cvsrep import ��

-m "Importacao inicial dos fontes da Portifolio" ��

-I .project -I .classpath -W "*.jar -k 'b' " places portifolio PLACES-1_0 4. A saída deve ser similar à figura a seguir. Observe que os arquivos que casaram com os padrões

.project e .classpath aparecem precedidos por I na saída. Isso indica que eles foram ignorados pelo comando import. Os demais arquivos são precedidos por N, indicando que eles são novos.

5. Lembre-se que o diretório C:\Fontes\places-1.0-src não é uma área de trabalho. Faça um check-out do novo módulo para o diretório estão as áreas de trabalho, C:\Trabalho. cvs –d /cvsrep checkout places

6. Verifique o status de um arquivo texto importado. Por exemplo, o arquivo places.xml no diretório src/java. cvs status src\java\places.xml


12

A saída é mostrada a seguir. Observe o número da revisão. Todos os arquivos importados foram automaticamente adicionados a um ramo de número 1.1.1, que corresponde ao fornecedor nomeado portifolio. Note a informação “Expansion option”: seu valor é kv, o default, adequado para arquivos texto.

7. Verifique agora o status de um arquivo binário. Por exemplo, o arquivo servlet-2.4.jar no diretório lib. cvs status lib\servlet-2.4.jar A saída deve ser similar à seguinte. Observe novamente a informação “Expansion option”: seu valor é b, apropriado para arquivos binários. Note também que essa opção é aderente, como mostrado na informação “Sticky Options”.

Tarefa 2: Importar uma nova liberação de um projeto

Quando um projeto é mantido por um fornecedor externo, é interessante poder importá-lo tantas vezes quanto necessário, geralmente, uma vez para cada liberação. 1. Entre no Windows ou no Linux como um usuário normal. 2. Extraia o arquivo places-2.0-src.zip, encontrado no material do aluno, para um diretório, por

exemplo, C:\Fontes\places-2.0-src. 3. Entre no diretório criado pela extração e importe os arquivos para o repositório.

C:\Fontes\places-2.0-src>cvs -d /cvsrep import ��

-m "Nova liberacao dos fontes da Portifolio" ��

-I .project -I .classpath -W "*.jar -k 'b' " places portifolio PLACES-2_0 4. A saída deve ser similar à figura a seguir. Observe que continuamos com os mesmos arquivos

ignorados, precedidos por I na saída. Temos alguns arquivos precedidos por N, indicando que eles são existiam na liberação anterior. A maioria dos arquivos aparece agora precedida por U, o que significa que eles foram atualizados (Updated). Isso não quer dizer que uma nova revisão foi criada no repositório; isso só acontece se o arquivo sendo importado for diferente da última revisão no repositório.


13

8. Atualize a área de trabalho para obter as últimas versões dos fontes. Vá para C:\Trabalho\places. Execute: cvs update A saída deve ser similar à seguinte. Observe a saída de update. As linhas precedidas por U indicam os arquivos que estão sendo atualizados na cópia local, portanto, tiveram novas revisões sendo criados por update.

9. Verifique o status de um arquivo atualizado. Por exemplo, o arquivo report.properties no diretório src/java. cvs status src\java\report.properties Observe que o número da revisão é 1.1.1.2. Verifique também o log desse arquivo. cvs log src\java\report.properties A saída deve ser similar à seguir.


14

Tarefa 3: Modificar o projeto e importar uma nova liberação

Veremos agora como lidar com uma situação na qual o projeto foi modificado (uma nova revisão de um arquivo foi criada) e uma nova liberação é importada, gerando um conflito. 1. Entre no Windows ou no Linux como um usuário normal. 2. Edite o arquivo src\java\report.properties, comentando todas as linhas contendo “.cache”. O

arquivo deve ficar com o seguinte conteúdo:

source.factory.rdb=br.com.portifolioti.places.dao.rdb.HsqldbDAOFactory

#source.factory.rdb.cache=true

source.factory.csv=br.com.portifolioti.places.dao.csv.CsvDAOFactory

#source.factory.csv.cache=true

source.factory.xml=br.com.portifolioti.places.dao.xml.XmlDAOFactory

#source.factory.xml.cache=true

3. Faça o check-in dessa alteração. cvs commit –m “Removido cache” A saída deve ser como a seguir.


15

4. Extraia o arquivo places-2.1-src.zip, encontrado no material do aluno, para um diretório, por exemplo, C:\Fontes\places-2.1-src.

5. Entre no diretório criado pela extração e importe os arquivos para o repositório. C:\Fontes\places-2.1-src>cvs -d /cvsrep import ��

-m "Ajuste dos fontes da Portifolio" ��

-I .project -I .classpath -W "*.jar -k 'b' " places portifolio PLACES-2_1 A figura abaixo mostra o início da saída desse comando. Observe que o arquivo src/java/report.properties aparece precedido por um C, indicando que houve um conflito na importação desse arquivo.

6. A figura abaixo mostra o final da saída do comando import. Note que o CVS destaca que houve um conflito e até sugere um comando para resolvê-lo com uma mescla. Não usaremos esse comando, por motivos que veremos na etapa avançada do curso.


16

7. Realize a mescla com o seguinte comando: cvs update –jportifolio src\java\report.properties Agora não veremos exatamente o que este comando faz, mas podemos dizer que ele toma as modificações realizadas entre a revisão ancestral (1.1) e a última revisão no ramo portifolio (1.1.1.3) e mescla estas modificações com a revisão na cópia de trabalho (1.2). A saída é mostrada na figura abaixo. O resultado da mescla é gravado no próprio arquivo e é exibido a seguir.

source.factory.rdb=br.com.portifolioti.places.dao.rdb.HsqldbDAOFactory

source.factory.rdb.cache=true

source.factory.csv=br.com.portifolioti.places.dao.csv.CsvDAOFactory

source.factory.csv.cache=true

source.factory.xml=br.com.portifolioti.places.dao.xml.XmlDAOFactory

<<<<<<< report.properties

#source.factory.xml.cache=true

=======

source.factory.xml.cache=true

>>>>>>> 1.1.1.3

8. Edite esse arquivo e mantenha a linha sem o comentário (aquela que estava presente na revisão 1.1.1.3). Faça o check-in do arquivo. cvs commit –m “Mescla com a liberacao 2.1” Veja que foi criada uma revisão 1.3 no tronco.


17


18

Lab2-4: Controlando Permissões

Objetivos

Ao final deste lab, você será capaz de: • Associar grupos a projetos e diretórios dentro de projetos. • Controlar permissões por grupos de usuários. • Verificar o funcionamento do controle de permissões do CVS.

Cenário

Neste lab, criaremos grupos de usuários e os associaremos a projetos (módulos) e diretórios dentro de projetos, usando mecanismos do sistema operacional do repositório. Com esses mesmos mecanismos, controlaremos as permissões a esses diretórios, de acordo com um critério pré-estabelecido. Verificaremos então que o controle de permissões funciona, tentando alterar um histórico usando um usuário que não tem esse direito.

Tarefa 1: Definir propriedades e permissões em um módulo

O mecanismo de autorização do CVS é fundamentado em propriedades e permissões sobre os arquivos do repositório. Nesta tarefa, controlaremos esses aspectos em um sistema de arquivos UNIX. 1. Importe os fontes no arquivo places-1.0-src.zip para o repositório no sistema Linux. Use o

usuário criado para você durante o Lab2-2. O instrutor, por exemplo, usará mneubert. Caso você já tenha feito o Lab2-3 no Linux, use o módulo já criado.

2. Entre no Linux como o usuário root. 3. Vá ao diretório /var/lib/cvs (ou a raiz do repositório que você tenha usado para a importação) e

verifique que o dono do diretório places, correspondente ao módulo, é o usuário que importou a liberação, enquanto que o grupo é cvs (devido ao bit SGID).

4. Crie um novo grupo para ser associado a projeto places: groupadd dev-places

5. Modifique a propriedade de grupo do diretório places: chgrp –R dev-places places

6. Inclua seu usuário pessoal nesse grupo. Note que, devido ao comportamento do comando usermod, é preciso verificar todos os grupos aos quais o usuário pertence e repeti-los na linha de comando, caso contrário, ele será removido dos grupos não listados. usermod mneubert –G ...,dev-places

7. Crie outro usuário, por exemplo, zsilva e o inclua no grupo cvs, mas não em dev-places. useradd –c “Outro usuario” –G cvs zsilva

mkdir /home/zsilva

chown zsilva:users /home/zsilva

passwd zsilva Use uma senha de sua preferência.

8. Vamos agora alterar a configuração do diretório de travas do CVS. Antes de sair do shell de root, crie o diretório cvs debaixo de /var/lock.


19

mkdir /var/lock/cvs

chmod g+rwx,o+rwt /var/lock/cvs 9. Entre no Linux com seu usuário pessoal (use su – como o usuário root ou entre em outro

terminal). Certifique-se de que esse usuário está no grupo cvs (o Lab2-2 fez essa configuração). 10. Faça um check-out de CVSROOT ou use uma área de trabalho existente. Edite o arquivo

config, incluindo a linha: LockDir=/var/lock/cvs É provável que, na distribuição Debian em uso, esta linha já esteja no arquivo, só que comentada. Faça um check-in desse arquivo.

Tarefa 2: Testar as configurações de permissões

Vamos agora testar o funcionamento das permissões. Faremos o teste com um usuário do grupo dev-places e outro que não pertence a esse grupo. 1. Ainda como seu usuário pessoal, edite um arquivo dentro do módulo places (faça um check-out

caso ainda não o tenha feito) e realize um commit. Por exemplo, inclua um comentário no arquivo Country.java (em src/java/br/com/portifolioti/places/domain/Country.java), como mostrado na figura a seguir e execute: cvs commit –m “Adicionado um comentario”

2. Observe que o comando teve sucesso. Tente agora realizar outra alteração (por exemplo, em City.java), agora com o usuário zsilva (entre em outro terminal com este usuário). Observe que, apesar do check-out ter funcionado, o check-in falhou, e o resultado é como mostrado pela figura abaixo:

3. Perceba que o CVS tentou a trava de escrita para o commit dentro do repositório e não conseguiu, devido às permissões configuradas. A trava de leitura foi criada dentro de /var/lock/cvs e não resultou em problemas.

4. (Opcional) Para testar o bloqueio de leitura, entre novamente como root e remova todas as permissões de outros ao diretório places: cd /var/lib/cvs

chmod o-rwx places Tente novamente fazer um check-out do módulo places como o usuário zsilva, para uma nova área de trabalho. Observe que a permissão é negada. Um diretório chega a ser criado, mas nenhum arquivo é obtido. Consulte a figura a seguir.


20


21

Lab2-5: Configurando o Acesso Remoto

Objetivos

Ao final deste lab, você será capaz de: • Instalar os softwares necessários para a comunicação SSH. • Criar chaves privadas e públicas. • Configurar a máquina cliente para o uso do shell SSH.

Cenário

Neste lab, configuraremos o CVS para o acesso ao servidor remoto pela forma mais segura, o método ext usando o shell SSH. Como provavelmente a configuração mais comum no uso do CVS é um cliente Windows acessando um servidor UNIX, exercitaremos esse cenário.

Tarefa 1: Verificar a instalação do servidor SSH (Linux)

O servidor CVS deve ter o SSH instalado para que clientes possam conectar usando o método ext e o protocolo SSH. A maioria das distribuições Linux tem o produto OpenSSH instalado. Nesta tarefa, verificaremos se isso é verdade para nosso servidor e testaremos a instalação. 1. Entre no Linux como root. Execute o instalador de pacotes do Debian para verificar que o

pacote ssh está instalado: apt-get update

apt-get install ssh É possível que o comando update gere alguns erros ou avisos, dependendo da configuração da ferramenta apt. A saída do comando install deve ser similar à seguinte:

2. Entre no Linux como seu usuário pessoal, para testar a instalação. No caso do instrutor, o usuário é mneubert. Informe-se com o pessoal do laboratório sobre o IP do servidor Linux. No exemplo abaixo, o IP é 192.168.163.128. Execute: ssh [email protected] O ssh dirá que não pode verificar a autenticidade da máquina que está se conectando e perguntará se você quer continuar. Responda yes. Ele pedirá a senha do usuário se conectando. Entre a senha do seu usuário. Você irá entrar em um prompt de comando de seu usuário, no servidor Linux, como mostrado pela figura a seguir. Com isso, verificamos a instalação do SSH no servidor.


22

Tarefa 2: Instalar um cliente SSH (Windows)

Para se comunicar com o servidor usando o protocolo SSH, é preciso que a máquina cliente tenha instalado um programa para esse tipo de conexão. Neste lab, usaremos o PuTTY, um cliente open-source para Windows. Esta tarefa conduzirá a instalação desse programa. 1. Execute o instalador do PuTTY, o arquivo putty-0.58-installer.exe encontrado nos materiais do

aluno.

2. Avance e selecione um local para a instalação do PuTTY. Você pode selecionar o local default ou, de preferência, indicar C:\PuTTY. Isso simplificará a inclusão o caminho para o executável do PuTTY em variáveis de ambiente. Clique “Next”.


23

3. Nos próximos passos, você irá definir onde o PuTTY criará seus atalhos, as extensões associadas a seus programas e revisará a instalação. Certifique-se de que chegou à seguinte tela:

4. Clique em “Install” para finalizar a instalação. Você receberá a seguinte tela:


24

Tarefa 3: Testar a conexão do cliente com o servidor

Antes de tentar utilizar o CVS com o método ext e o SSH, é importante testar a conexão direta com o SSH. Esta tarefa faz esse teste. 1. Chame o PuTTY pelo

Menu “Iniciar” do Windows. A tela principal dele será exibida.

2. Digite o endereço IP do servidor CVS (o mesmo utilizado na tarefa anterior) no campo “Host Name (or IP address)” e um nome (por exemplo, cvs) no campo “Saved Sessions”. Clique em “Save”. O nome da conexão deve surgir na lista de conexões salvas, logo abaixo de “Default Settings”. Veja a figura ao lado.


25

3. Clique em “Open”. Se você não se conectou anteriormente no servidor a partir do Windows, o PuTTY mostrará a seguinte tela de alerta. Confirme em “Sim”.

4. O PuTTY abrirá uma linha de comando pedindo um nome de usuário. Informe seu usuário pessoal e, em seguida, sua senha. Você deve conseguir entrar em um shell remoto com seu usuário pessoal, como mostrado na figura adiante. Com isso, você acaba de validar a conexão cliente/servidor pelo protocolo SSH. Entretanto, para que o CVS possa utilizar essa conexão, não deve ser preciso informar login e senha, como fizemos. Para evitar que o servidor SSH peça uma senha na conexão, devemos gerar uma chave privada para nosso cliente, o que faremos na próxima tarefa.

Tarefa 4: Gerar uma chave privada para o cliente

Antes de tentar utilizar o CVS com o método ext e o SSH, é importante testar a conexão direta com o SSH. Esta tarefa faz esse teste.


26

1. Chame o programa PuTTYgen pelo Menu “Iniciar” do Windows, dentro do grupo de aplicativos “PuTTY”. A tela principal dele será exibida, como mostrado a seguir.

2. Clique em “Generate” para gerar um par de chaves pública/privada. O programa pedira para que você mova o mouse sobre a janela para gerar aleatoriedade. Faça isso e, ao final do processamento, uma chave será gerada, como mostrado a seguir.


27

3. Copie o conteúdo no campo “Public key for pasting into OpenSSH authorized_keys file”, usando Control-C. Abra um terminal PuTTY no Linux, usando seu usuário pessoal. Entre no diretório .ssh no home desse usuário e edite um arquivo chamado authorized_keys. Copie o conteúdo selecionado para esse arquivo (no PuTTY, basta clicar com o botão direito do mouse sobre o terminal). Confira que este arquivo tem somente essa linha. Salve-o.

4. Entre uma senha nos campos “Key passphrase” e “Confirm passphrase”. Essa senha manterá sua chave privada segura em sua máquina. Clique em “Save private key” e indique um diretório no Windows para armazenar sua chave. Por exemplo, C:\Trabalho. Escolha um nome para seu arquivo.

5. Chame agora o programa Pageant, também no grupo “PuTTY”. Este programa gerencia suas chaves privadas e permite que programas se conectem usando essas chaves. Ele é um serviço e, após iniciado, aparecerá como um ícone na barra de tarefas.

6. Clique no ícone com o botão direito e selecione a opção “View Keys”. O Pageant mostrará uma lista vazia de chaves, como a seguir.


28

7. Selecione a chave salva no passo anterior, no diretório C:\Trabalho. Como você usou uma senha para torná-la segura, o Pageant pedirá novamente essa senha, como mostrado abaixo. Informe-a.

8. O Pageant mostrará a chave na lista. Você pode agora clicar em “Close”. O Pageant continuará executando.

9. Teste agora que a chave está sendo usada pelo PuTTY no lado cliente e está sendo aceita pelo servidor. Inicie uma nova sessão do PuTTY. Carregue a configuração salva (cvs) e vá ao item “Connection”, sub-item “Data”. No campo “Auto-login username”, indique o nome de seu usuário pessoal no Linux, como mostrado abaixo.


29

10. Clique em “Open”. O terminal deve ser aberto no servidor sem a necessidade de informar uma senha. Isso significa que o servidor aceitou a chave privada, que foi provida pelo programa Pageant. Veja a figura abaixo e observe a mensagem “Authenticating with public key...”.


30

Tarefa 5: Configurar CVS_RSH e realizar um check-out

Uma vez configurada a conexão cliente/servidor pelo SSH com chaves pública/privada, basta configurar a variável de ambiente CVS_RSH no cliente, para que ela aponte para um shell SSH. Em seguida, testamos nossa configuração fazendo um check-out de um módulo. 1. Abra um prompt de comando no Windows. Configure a variável de ambiente CVS_RSH da

seguinte forma: set CVS_RSH= "c:\Arquivos de programas\PuTTY\plink.exe" Substitua o caminho para o executável plink.exe com seu o diretório de instalação do PuTTY. O plink.exe é o executável do PuTTY adequado para conexões não-interativas. Caso deseje que a variável CVS_RSH seja disponível para outros prompts, basta defini-la na aba “Avançado” das propriedades do “Meu computador”.

2. Faça um check-out do módulo places. Para evitar que a nova área de trabalho sobre uma já existente, faça com que check-out crie uma área de trabalho chamada places-ext: cvs -d :ext:[email protected]:/var/lib/cvs co -d places-ext places O comando deve ter sucesso, como mostrado a seguir.

Curso de CVS - Lab 2

Technology

Transcript of Curso de CVS - Lab 2