Curso de CVS - Lab 2

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

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:

1


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

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.

2


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.

3


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.

4


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.

5


Lab2-2: Criando um Repositório
Objetivos
• 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.

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

6


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.

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.


7


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.
8


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.

9


Lab2-3: Importando Projetos
Objetivos
• 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:Fontesplaces-1.0-
src. Este diretório não
será uma área de
trabalho, apenas um
temporário para a
importação dos fontes.

10


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:Fontesplaces-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:Fontesplaces-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 srcjavaplaces.xml
11


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 libservlet-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:Fontesplaces-2.0-src.
3. Entre no diretório criado pela extração e importe os arquivos para o repositório.
-m "Nova liberacao dos fontes da Portifolio"
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.

12


8. Atualize a área de trabalho para obter as últimas versões dos fontes. Vá para
C:Trabalhoplaces. 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 srcjavareport.properties
Observe que o número da revisão é 1.1.1.2. Verifique também o log desse arquivo.
cvs log srcjavareport.properties
A saída deve ser similar à seguir.

13


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 srcjavareport.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.

14


4. Extraia o arquivo places-2.1-src.zip, encontrado no material do aluno, para um diretório, por
exemplo, C:Fontesplaces-2.1-src.
5. Entre no diretório criado pela extração e importe os arquivos para o repositório.
-m "Ajuste dos fontes da Portifolio"
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.

15


7. Realize a mescla com o seguinte comando:
cvs update –jportifolio srcjavareport.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.

16


17


Lab2-4: Controlando Permissões
Objetivos
• 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.

18


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.

19


20


Lab2-5: Configurando o Acesso Remoto
Objetivos
• 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 mneubert@192.168.163.128
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.

21


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”.

22


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:

23


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.

24


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.

25


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.

26


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.

27


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.
28


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...”.

29


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 programasPuTTYplink.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:mneubert@192.168.163.128:/var/lib/cvs co -d places-ext places
O comando deve ter sucesso, como mostrado a seguir.

30

Curso de CVS - Lab 2

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (7)

Semelhante a Curso de CVS - Lab 2

Semelhante a Curso de CVS - Lab 2 (20)

Curso de CVS - Lab 2