Este é um tutorial prático (mão na massa de verdade) que faz um overview de parte dos assuntos que são explicados detalhadamente em cada tópico do livro/curso "JBoss em Produção" (HTML).
Os requisitos para a execução desse tutorial são bem reduzidos em relação aos do curso pois, nele, não solicito a instalação do Fedora como máquina base para todas os laboratórios que estão disponíveis. Sendo assim, esse tutorial oferece uma visão simplificada com um startup rápido para várias tarefas que são minuciosamente cobertas durante o curso.
Para começar o tutorial você precisará de um Linux (ou um OS X) instalado em tua máquina. Ela também deverá ter pelo menos 4 GB de memória RAM e 8 GB de espaço livre em disco. O Linux pode ser de qualquer distribuição: Debian, Ubuntu, Arch Linux, Fedora, …, a que você quiser! Em seguida, você precisará instalar algumas ferramentas nesse Linux. São elas:
-
O servidor OpenSSH
-
Procedimentos de instalação no Ubuntu
-
-
O virtualizador VirtualBox
-
Procedimentos de instalação no Ubuntu
-
-
O utilitário para (des)compactação 7zip
Após ter instalado essas ferramentas, você fará o download de uma VM contendo uma versão do CentOS que, como sabemos, é gerado a partir dos fontes do Red Hat Enterprise Linux (RHEL) e é uma das distribuições mais adequadas para o estudo do JBoss EAP em ambiente de produção. Além disso, por ser totalmente baseado no RHEL, a utilização do CentOS ofere toda a experiência necessária em Linux para aqueles que desejam fazer o exame RHCJA.
Acredito que também seja possível executar no Janelas as tarefas que apresento aqui, com o auxílio do Cygwin. Contudo, eu ainda não tive tempo (nem paciência de sobra) para experimentar isso (e se eu o fizer algum dia você saberá ;)).
Encarando de frente a execução desse tutorial, eu acredito que você terá uma boa visão dos tópicos que serão aprofundados no curso. Além disso, você poderá avaliar se, com minhas explicações, terá uma compreensão dos assuntos que extrapolam o objetivo principal do curso, que é falar sobre o servidor de aplicações JBoss. Assim como você verá nesse tutorial, o curso vai muito além desse servidor pois apresenta assuntos como a instalação e a configuração de virtualizadores, sistemas operacionais, redes, servidores (HTTP(S), SSH, FTP, …), banco de dados, etc. Enfim, oferece uma visão extremamente abrangente de toda a infraestrutura em torno do servidor de aplicações além de um ótimo conhecimento para o desenvolvimento de scripts Bash.
Espero, sinceramente, que você se divirta executando esse tutorial (assim como eu me diverti ao escrevê-lo :D)! Então …
Presumindo que você já tenha realizado as instalações que solicitei (VirtualBox, 7zip, OpenSSH server, …), abra um shell Bash em tua máquina (chamarei-a de base).
Baixe os arquivos de minha vm-centos (será realizado o download de aproximadamente 400 MB):
mkdir -p ~/VirtualBox\ VMs
cd !$
bash <(curl -L http://j.mp/vm-centos-download)Utilizando o 7zip, extraia o conteúdo da VM:
7za x vm-centos.7z.001Registre a VM:
VBoxManage registervm "$PWD/vm-centos/vm-centos.vbox"Crie e configure uma interface host-only para a máquina base:
VBoxManage hostonlyif create
VBoxManage hostonlyif ipconfig vboxnet0 --ip 192.168.0.253 --netmask 255.255.255.0Desabilite o servidor DHCP associado a essa interface:
VBoxManage dhcpserver remove --netname HostInterfaceNetworking-vboxnet0Modifique a VM adicionando uma nova interface associada a esse adaptador:
VBoxManage modifyvm vm-centos --nic2 hostonly --hostonlyadapter2 vboxnet0Modifique e verifique o conteúdo do teu arquivo /etc/hosts:
f=/etc/hosts; grep -q vm-centos $f || echo -e "192.168.0.254\tvm-centos" | sudo tee -a $f
cat $fInicie a VM:
VBoxManage startvm vm-centosAbra o console da VM e efetue o logon como usuário aluno (senha @lun0123).
Logue-se como root:
sudo su -Observe que agora há duas interfaces de rede além da lo (eth0 e eth1):
ip a sObtenha e imprima o endereço de hardware da interface eth1:
HWADDR=$(ip a s eth1 | grep ether | awk '{ print $2 }' | tr '[:lower:]' '[:upper:]')
echo $HWADDRConfigure o arquivo que associará um IP estático para a nova interface de rede. Em seguida, veja seu conteúdo:
f=/etc/sysconfig/network-scripts/ifcfg-eth1; cat > $f <<EOF
DEVICE=eth1
BOOTPROTO=static
IPADDR=192.168.0.254
HWADDR=$HWADDR
NM_CONTROLLED=yes
ONBOOT=yes
EOF
cat $fReinicie os serviços de rede:
service network restartVerifique se o IP foi associado a interface eth1:
ip a s eth1Faça um ping no IP da interface vboxnet0 na máquina base:
ping 192.168.0.253Teste se a resolução de nomes através do DNS está ok:
host google.comVerifique o gateway default e a tabela de rotas:
ip route show
route -nEfetue o logout e volte para o shell na máquina base:
exit
logoutFaça um SSH na vm-centos:
ssh aluno@vm-centosPasso opcional: se você possui um mirror local do CentOS, desabilite os repositórios remotos e habilite apenas os locais:
sudo yum-config-manager --disable base,updates,extras
sudo yum-config-manager --enable local-mirror-*Atualize a lista de pacotes:
sudo yum -y updateInstale o Git:
sudo yum -y install gitBaixe o repositório do curso e o projeto dotfiles dentro dele:
git clone https://github.com/paulojeronimo/livro-jboss curso-jboss
cd !$
git clone https://github.com/paulojeronimo/dotfilesInstale o projeto dotfiles, encerre sua sessão e refaça o logon via SSH:
dotfiles/install
logoutCopie tua chave pública para a VM e efetue um novo SSH:
ssh-copy-id aluno@vm-centos
ssh !$Instale o tree:
sudo yum -y install treeVerifique a árvore de diretórios/arquivos do curso:
tree ~/curso-jboss | lessInstale o asciidoc:
sudo yum -y install asciidoc
sudo yum -y install http://epel.gtdinternet.com/6/i386/epel-release-6-8.noarch.rpm
sudo yum -y install source-highlightInstale o asciidoctor e suas dependências:
curl -sSL https://get.rvm.io | sudo -E bash -s stable
sudo gpasswd -a $USER rvm
logout
ssh aluno@vm-centos
rvm install 2.1
gem install tilt asciidoctor slimFaça um ajuste no arquivo ~/.gitconfig. Isso é necessário pois a versão do Git instalada no CentOS (1.7.1) não suporta a configuração especificada nas duas últimas linhas desse arquivo:
rm .gitconfig
head -n -2 curso-jboss/dotfiles/.gitconfig > !$
vim -d .gitconfig curso-jboss/dotfiles/.gitconfig
# digite :qa! para sair do vimObserve que as páginas HTML do curso ainda não foram geradas:
cd curso-jboss/
find . -type f -name '*.html'Então, agora faça o build dessas páginas e reexecute o find anterior:
./build
!-2Instale e inicie o Apache:
sudo yum -y install httpd
sudo service httpd startVerifique o processo que está escutando na porta 80:
sudo lsof -i :80Habilite a inicialização automática do Apache:
sudo chkconfig httpd on
sudo chkconfig --list httpdConfigure o firewall para liberar o acesso a porta 80:
sudo iptables -I INPUT -s 192.168.0.0/24 -m state --state NEW -p tcp --dport 80 -j ACCEPT
sudo service iptables saveConfigure o acesso via Apache ao diretório do curso:
sudo chmod +x $HOME
mkdir ~/public_html
cd !$
ln -s ../curso-jbossEdite o arquivo de configuração do Apache para habilitar o acesso ao diretório ~/public_html.
d=/etc/httpd/conf/; sudo cp $d/httpd.conf $d/httpd.conf.1
sudo vim $d/httpd.confApresento a saída do comando diff httpd.conf{.1,}. Ela informa as diferenças entre o arquivo original (httpd.conf.1) e o editado. Observe-as para saber o que você deve modificar em httpd.conf:
276c276
< #ServerName www.example.com:80
---
> ServerName 192.168.0.254
366c366
< UserDir disabled
---
> #UserDir disabled
373c373
< #UserDir public_html
---
> UserDir public_html
381,392c381,392
< #<Directory /home/*/public_html>
< # AllowOverride FileInfo AuthConfig Limit
< # Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec
< # <Limit GET POST OPTIONS>
< # Order allow,deny
< # Allow from all
< # </Limit>
< # <LimitExcept GET POST OPTIONS>
< # Order deny,allow
< # Deny from all
< # </LimitExcept>
< #</Directory>
---
> <Directory /home/*/public_html>
> AllowOverride FileInfo AuthConfig Limit
> Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec
> <Limit GET POST OPTIONS>
> Order allow,deny
> Allow from all
> </Limit>
> <LimitExcept GET POST OPTIONS>
> Order deny,allow
> Deny from all
> </LimitExcept>
> </Directory>Recarregue as configurações do Apache (não é necessário reiniciá-lo):
sudo service httpd reloadAjuste o SELinux para permitir o acesso ao diretório do usuário via HTTP:
sudo getsebool -a | grep httpd | less
sudo setsebool -P httpd_read_user_content 1
sudo setsebool -P httpd_enable_homedirs 1
sudo getsebool -a | grep httpd | grep on$O parâmetro -a passado ao getsebool solicita que sejam impressos todos os booleans do SELinux. Já o parâmetro -P passado ao setsebool serve para tornar permanente (sobrevivente as reinicializações do S.O.) o valor informado para a variável booleana.
De um browser na máquina base, teste o acesso a URL http://vm-centos/~aluno/curso-jboss
Para executar o JBoss, será necessária a instalação de um JDK. Instalar o OpenJDK é o suficiente:
sudo yum -y install java-1.7.0-openjdk-devel
java -versionAbra um browser na máquina (base) e faça o download do JBoss EAP a partir da URL http://www.jboss.org/products/eap/download/. Para esse tutorial, faça o download desse arquivo da versão 6.2.0.GA: http://www.jboss.org/download-manager/file/jboss-eap-6.2.0.GA.zip
Crie e copie o arquivo baixado na máquina base para o diretório ~/curso-jboss/instaladores
mkdir -p ~/curso-jboss/instaladores
cd !$
read -p 'Informe teu usuário na máquina base: ' BASE_USER
read -p 'Informe o diretório onde foi baixado o JBoss: ' DOWNLOADS_DIR
scp $BASE_USER@base:$DOWNLOADS_DIR/jboss-eap-6.2.0.zip .Crie o diretório ~/curso-jboss/ferramentas e descompacte o JBoss dentro dele:
mkdir ../ferramentas
cd !$
unzip ../instaladores/jboss-eap-6.2.0.zipCrie o link jboss para o diretório onde o JBoss foi descompactado:
ln -s jboss-eap-6.2 jbossCrie o arquivo ~/curso-jboss/ambiente para configurar variáveis de ambiente $PATH:
ambiente=~/curso-jboss/ambiente
tee $ambiente <<EOF > /dev/null
# Informa o nome do usuário na máquina base:
BASE_USER=$BASE_USER
# Informa o diretório de downloads na máquina base:
DOWNLOADS_DIR=$DOWNLOADS_DIR
EOF
tee -a $ambiente <<'EOF' > /dev/null
# Informa a localização do JBoss e ajusta o PATH para seus executáveis:
JBOSS_HOME=~/curso-jboss/ferramentas/jboss
PATH=$JBOSS_HOME/bin:$PATH
EOF
cat $ambiente
type setenv
setenv $ambienteEfetue o logout e logue-se novamente. Em seguida, verifique se o PATH foi ajustado:
logout
ssh aluno@vm-centos
echo $PATH | tr ':' '\n' | grep jbossInicie o JBoss:
standalone.shPressione 'Ctrl+Z' para parar o processo do JBoss e em seguida, digite 'bg' para executá-lo em background.
Note o WARN apresentado no log de execução do JBoss. Ele representa um problema que precisaremos resolver.
Observe algumas informações sobre o JBoss em execução:
jps -Vvlm | grep --color '\-Xm'
JBOSS_PID=`jps -Vvlm | grep Standalone | cut -d " " -f 1`
lsof -p $JBOSS_PID -P -n | grep LISTENSolucione o problema do WARN adicionando o nome vm-centos no arquivo /etc/hosts/:
grep -q vm-centos /etc/hosts || \
sudo sed -i 's/\(127.0.0.1.*\)/\1 vm-centos/' /etc/hostsDiminua a quantidade de memória solicitada na inicialização do JBoss:
sed -i 's/1303/512/g' $JBOSS_HOME/bin/standalone.confAgora pare o JBoss e execute-o novamente. Observe que o WARN não deverá mais aparecer, a quantidade de memória alocada deverá ser inferior e o tempo de inicialização menor:
kill $JBOSS_PID
c=standalone.sh; nohup $c 2>&1 | tee /tmp/$c.log &Novamente, pare o JBoss:
jboss-cli.sh -c :shutdownA habilidade de fazer um serviço subir automaticamente na inicialização da máquina é uma característica desejada em servidores. Fazer isso acontecer no JBoss é bastante fácil. Para deixar as coisas ainda mais simples, vamos deixar o JBoss ser iniciado pelo próprio usuário aluno.
Primeiro copie o script de iniciacialização do JBoss para o local adequado, conforme a seguir:
cd $JBOSS_HOME/bin
sudo cp init.d/jboss-as-standalone.sh /etc/init.d/jbossEdite o script copiado:
sudo vim /etc/init.d/jbossPara fazer as mudanças, baseie-se na saída do comando diff entre o arquivo original ($JBOSS_HOME/bin/init.d/jboss-as-standalone.sh) e o editado:
25a26
> JBOSS_USER=aluno
28c29
< JBOSS_HOME=/usr/share/jboss-as
---
> JBOSS_HOME=/home/aluno/curso-jboss/ferramentas/jbossTeste o script de inicialização:
sudo /etc/init.d/jboss start
sudo /etc/init.d/jboss status
ps -ef | grep java
sudo /etc/init.d/jboss stop
!-2Registre o script de inicialização:
sudo chkconfig --add jboss
sudo chkconfig jboss on
sudo chkconfig --list jbossPor fim, como último teste, reinicie a VM e verifique se durante o boot o JBoss é iniciado automaticamente:
sudo shutdown -r nowPara acessar a interface administrativa do JBoss, será necessário criar um usuário que possua tais privilégios. Para isso, refaça o login na máquina vm-centos como usuário aluno
ssh aluno@vm-centosExecute:
# informe o usuário 'admin' e a senha 'jb@ss123' (sem os apoóstrofos)
add-user.shObserve as respostas que você deverá ter ao executar o comando anterior:
What type of user do you wish to add? a) Management User (mgmt-users.properties) b) Application User (application-users.properties) (a): Enter the details of the new user to add. Using realm 'ManagementRealm' as discovered from the existing property files. Username : admin The username 'admin' is easy to guess Are you sure you want to add user 'admin' yes/no? yes Password : Re-enter Password : What groups do you want this user to belong to? (Please enter a comma separated list, or leave blank for none)[ ]: About to add user 'admin' for realm 'ManagementRealm' Is this correct yes/no? yes Added user 'admin' to file '/home/aluno/curso-jboss/ferramentas/jboss-eap-6.2/standalone/configuration/mgmt-users.properties' Added user 'admin' to file '/home/aluno/curso-jboss/ferramentas/jboss-eap-6.2/domain/configuration/mgmt-users.properties' Added user 'admin' with groups to file '/home/aluno/curso-jboss/ferramentas/jboss-eap-6.2/standalone/configuration/mgmt-groups.properties' Added user 'admin' with groups to file '/home/aluno/curso-jboss/ferramentas/jboss-eap-6.2/domain/configuration/mgmt-groups.properties' Is this new user going to be used for one AS process to connect to another AS process? e.g. for a slave host controller connecting to the master or for a Remoting connection for server to server EJB calls. yes/no? no
Faça o logout e conecte-se novamente, via SSH, criando túneis para as portas 8080 (aplicações) e 9990 (gerenciamento via web):
logout
ssh -L 8080:localhost:8080 -L 9990:localhost:9990 aluno@vm-centosNa máquina base, abra o browser em http://localhost:8080. Em seguida, clique no link Administration Console. Informe o usuário e a senha cadastrados anteriormente. Navegue pela interface administrativa …
Feche a conexão SSH. Obviamente, após fazer isso, os túneis serão desfeitos e o acesso as portas 8080 e 9990 não será mais possível! Mesmo assim, é claro que o JBoss continuará em execução …
logoutEfetue o logon novamente. Baixe e instale o Maven. Utilize esse instalador: http://ftp.unicamp.br/pub/apache/maven/maven-3/3.2.2/binaries/apache-maven-3.2.2-bin.tar.gz.
ssh aluno@vm-centos
cd ~/curso-jboss/instaladores
scp $BASE_USER@base:$DOWNLOADS_DIR/apache-maven-3.2.2-bin.tar.gz .
cd ../ferramentas/
tar xvfz ../instaladores/apache-maven-3.2.2-bin.tar.gz
ln -s apache-maven-3.2.2 maven
tee -a ../ambiente <<'EOF' > /dev/null
# Informa a localização do Maven e ajusta o PATH para seus binários:
M2_HOME=~/curso-jboss/ferramentas/maven
PATH=$M2_HOME/bin:$PATH
EOFRefaça o logon e teste se o Maven está funcionando:
logout
ssh aluno@vm-centos
mvn -versionBaixe os quickstarts (http://www.jboss.org/download-manager/file/jboss-eap-6.2.0.GA-quickstarts.zip) e faça sua descompatação no diretório exemplos do curso:
cd ~/curso-jboss/instaladores
scp $BASE_USER@base:$DOWNLOADS_DIR/jboss-eap-6.2.0-quickstarts.zip .
mkdir -p ../exemplos
cd !$
unzip ../instaladores/jboss-eap-6.2.0-quickstarts.zipCopie as configurações do Maven, necessárias para o build:
mkdir -p ~/.m2
cd jboss-eap-6.2.0.GA-quickstarts
cp settings.xml ~/.m2/Compile e implante a aplicação HelloWorld:
cd helloworld
mvn clean install jboss-as:deployRefaça o logon abrindo os túneis SSH:
logout
ssh -L 8080:localhost:8080 -L 9990:localhost:9990 aluno@vm-centosTeste o acesso ao contexto da aplicação helloworld através da URL http://localhost:8080/jboss-helloworld/.
Efetue o logout novamente:
logoutO comando SSH executado acima é meio chato e grande e será executado várias vezes, não é? Podemos simplificá-lo …
Execute o seguinte comando para adicionar conteúdo ao arquivo ~/.ssh/config da máquina base:
tee -a ~/.ssh/config <<EOF > /dev/null
Host vm-centos
Hostname vm-centos
User aluno
Host jboss-tunnels-vm-centos
Hostname vm-centos
User aluno
LocalForward 8080 localhost:8080
LocalForward 9990 localhost:9990
EOFAgora, acesse novamente a vm-centos, mas utilizando esse comando:
ssh jboss-tunnels-vm-centosEntão, com as configurações acima, não é mais necessário informar o usuário e os parâmetros para a criação dos túneis. Eles são criados automaticamente ao utilizar o alias (jboss-tunnels-vm-centos) como parâmetro para o ssh. legal, não é?
Abra outro shell, na máquina base, e verifique que as portas 8080 e 9990 estão em listen pelo processo ssh:
lsof -i :8080 -P
lsof -i :9990 -PTalvez, nosso intuito seja apenas criar os túneis, sem precisar de acesso a máquina vm-centos. Isso também pode ser feito, informando alguns parâmetros na chamada ao ssh. Para isso, feche a conexão na máquina base e, em seguida, execute o ssh novamente, conforme as instruções a seguir:
ssh -f -N jboss-tunnels-vm-centosO parâmetro -f informa que o ssh deverá ser executado em background e o -N que não será executado nenhum comando remoto. Dessa forma, os túneis serão criados e ficarão disponíveis mas, não estaremos logados na vm-centos.
Veja que o ssh está em execução e encerre-o, com os comandos a seguir:
ps -ef | grep ssh
pkill ssh
!-2Para simplificar ainda mais, a criação de um alias pode ser útil. Execute e teste:
alias jboss-tunnels-vm-centos='ssh -f -N jboss-tunnels-vm-centos'
jboss-tunnels-vm-centos
!?ps
!?pkillVocê pode tornar esse alias disponível a cada inicialização de um shell incluindo a linha acima no arquivo \~/.bashrc ou ~/.profile (no OS X).
Se não fizermos o túnel para acessar a porta 8080 localmente ou se não tornarmos esta porta ser acessível através do endereço da vm-centos, por exemplo para acessar a aplicação helloworld (URL http://vm-centos:8080/jboss-helloworld), como poderemos acessá-la via browser?
Existem várias alternativas para isso … boas e más. Porém, uma delas é colocar o Apache HTTPD como frontend para o JBoss. Faremos isso agora, utilizando o mod_proxy e, quando eu falar de clusters, de outras formas.
Em termos de produção, por questões de segurança, é bom mesmo que o JBoss só seja acessível através de um frontend. Você deve ter notado que, nesse tutorial, eu não faço nem mesmo questão de que o JBoss faça seja iniciado fazendo o bind no IP público (192.168.0.254) da vm-centos. Foi por esse motivo que eu expliquei o uso de túneis SSH. ;)
Logue-se novamente na vm-centos como aluno e, em seguida, como root:
ssh jboss-tunnels-vm-centos
sudo su -Observe que, no comando ssh acima não informamos o usuário (aluno) mas, mesmo assim, o login foi realizado (como ele). Isso ocorreu devido a configuração que fizemos anteriormente no arquivo ~/.ssh/config.
Antes de editar, faça um cópia do arquivo /etc/httpd/conf/httpd.conf:
cd /etc/httpd/conf
cp httpd.conf httpd.conf.2Altere o arquivo conforme o comando a seguir:
tee -a httpd.conf <<EOF > /dev/null
ProxyPass /jboss-helloworld http://localhost:8080/jboss-helloworld
ProxyPassReverse /jboss-helloworld http://localhost:8080/jboss-helloworld
EOFReinicie o Apache:
service httpd restartDa máquina base, acesse a URL http://vm-centos/jboss-helloworld.
Não deu certo, não é? Faltou um pequeno detalhe. Vamos descobrir o problema! Para isso, vejamos os logs do Apache:
cd /var/log/httpd
tail -f *Refaça a requisição a URL informada e observe que na saída do arquivo errro_log você deverá receber uma linha similar a essa:
[Wed Jul 16 15:45:56 2014] [error] proxy: HTTP: disabled connection for (localhost)
Esse é o problema! Pode dar um 'Ctrl+C' na execução do tail. Geralmente, a primeira coisa que observo nesses tipos de casos (negação de serviço) é o SELinux. E, para esse caso específico, execute a seguinte instrução:
setsebool -P httpd_can_network_connect 1Não é necessário reiniciar o Apache após executar essa instrução. Agora, tente novamente o acesso a URL e voilà! Don’t Worry Be Happy! ;)
Agora eu quero que a aplicação helloworld seja acessada através da seguinte URL http://helloworld.vm-centos.
Observando a URL que já acessamos (http://vm-centos/jboss-helloworld/HelloWorld) podemos notar três elementos:
-
O nome do servidor (vm-centos)
-
O contexto web (jboss-helloworld)
-
O recurso (HelloWorld - desenvolvedores lendo a aplicação saberão que trata-se de um Servlet)
Na nova URL que será utilizada, o nome helloworld.vm-centos será o nome de um virtual host. Eu não quero que a aplicação seja acessada através desse nome e mais o nome do contexto, ou seja, não quero ter que acessar http://helloworld.vm-centos/jboss-helloworld. Então, além de fazer a criação de um virtual host, também será necessário tornar o contexto jboss-helloworld, o contexto root (/) desse virtual host. Logo, teremos dois trabalhos aqui …
Antes de fazer a configuração do virtual host vamos ajustar o JBoss para tornar o contexto jboss-helloworld o seu contexto root.
Se você está logado como root, volte a ser o usuário aluno:
logoutAgora, execute alguns comandos através da CLI (Command Line Interface) do JBoss:
f=/tmp/jboss-cmds.cli
cat > $f <<EOF
batch
/subsystem=web/virtual-server=default-host:write-attribute(name=enable-welcome-root,value=false)
/subsystem=web/virtual-server=default-host:write-attribute(name=default-web-module,value=jboss-helloworld)
:shutdown(restart=true)
run-batch
EOF
jboss-cli.sh -c --file=$fA execução dos comandos acima faz os ajustes necessários no JBoss e em seguida, manda reiniciá-lo.
Você poderá observar, agora, que ao acessar a URL http://localhost:8080, o contexto root (/) do JBoss será a aplicação helloworld.
Como não estamos utilizando nenhum servidor de DNS nesse tutorial, precisaremos ajustar esse nome no arquivo /etc/hosts da máquina base. Então, num shell aberto nessa máquina, execute:
f=/etc/hosts; grep -q 'helloworld\.vm-centos' $f ||
echo -e '192.168.0.254\thelloworld.vm-centos' | sudo tee -a $fDe volta ao shell aberto na máquina vm-centos vamos fazer algumas configurações no Apache:
cd /etc/httpd/conf
sudo cp httpd.conf httpd.conf.3
sudo cp httpd.conf.2 httpd.confEdite a configuração do novo virtual host em httpd.conf:
sudo vim httpd.confApresento a saída do comando diff httpd.conf{.2,}. Ela mostra as diferenças entre o arquivo original e o editado. Utilize-a para saber o precisa ser modificado:
990c990
< #NameVirtualHost *:80
---
> NameVirtualHost *:80
1009a1010,1018
> <VirtualHost *:80>
> DocumentRoot /var/www/html
> </VirtualHost>
> <VirtualHost *:80>
> ServerName helloworld.vm-centos
> ProxyRequests off
> ProxyPass / http://localhost:8080/
> ProxyPassReverse / http://localhost:8080/
> </VirtualHost>Faça o reload das configurações do Apache:
sudo service httpd reloadTeste o acesso a URL http://helloworld.vm-centos.
Desligue a VM:
ssh -t aluno@vm-centos sudo shutdown -h nowRemova a interface vboxnet0:
VBoxManage hostonlyif remove vboxnet0Remova a VM:
VBoxManage unregistervm vm-centos --deleteRemova a entrada vm-centos do arquivo /etc/hosts na máquina base:
sudo sed -i '/vm-centos/d' /etc/hosts
cat !$Remova as linhas adicionadas ao arquivo ~/.ssh/config na máquina base.