Gerenciar Máquina Virtual no VMware ESXi via console (SSH)

Basicamente para controlar as VMs utiliza-se o comando vim-cmd vmsvc

Primeira coisa, você deve saber o ID da máquina virtual que você deseja manipular:

Listar máquinas registradas:
# vim-cmd vmsvc/getallvms

Visualizar o sumário da máquina:
# vim-cmd vmsvc/get.summary [ID]

Para ligar uma VM:
# vim-cmd vmsvc/power.on [ID]

Para desligar uma VM: 
# vim-cmd vmsvc/power.off [ID]

Para suspender uma VM
# vim-cmd vmsvc/power.suspend [ID]

Existem muitos outros…

Fontes:
http://blogs.vmware.com/vsphere/2011/03/ops-changes-part-6-quick-troubleshooting-tips.html
http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1038043

Resolvendo problema de conexão entre servidores ESXi para transferência de VMs

Vamos ao problema:

1. Você tem habilitado o acesso SSH, e a conexão entre um cliente desktop (putty, ssh secure shell…) e o servidor funciona normalmente. OK

2. Estando conectado ao servidor ESXI você resolve transferir uma VM para outro servidor ESXI utilizando SCP, algo como isto:

# cd /vmfs/volumes/datastore1

# scp -r vmxpto root@192.168.100.20:/vmfs/volumes/datastore1

porém a conexão não é estabelecida e o único erro exibido é:

# ssh: connect to host 192.168.100.20 port 22: Connection timed out

O problema é o perfil de segurança em cada um dos servidores ESXi.

Para resolver:

1. Conecte via cliente vSphere

2. Clica no servidor (lateral esquerda), em seguida vá até aba Configuration e clique em Security Profile no grupo Software e depois em Properties do Firewall.

3. Então, você só precisa marcar o SSH Client em Secure Shell. Isto irá abrir a comunicação SSH entre os servidores ESXi. Você pode restringir as configurações, acessando as configurações de firewall para qualquer um dos serviços.

Você também pode habilitar via linha de comando, diretamente do console dos servidores, utilizando o esxcli:

Para listar a configuração atual:
# esxcli network firewall ruleset list

Para habilitar o SSH Client e permitir a cópia usando SSH:
# esxcli network firewall ruleset set –ruleset-id sshClient –enabled yes

Se você estiver utilizando o ESXI 5.1 você faz assim:
# esxcli network firewall ruleset set -e true -r sshClient

Para atualizar a configuração:
# esxcli network firewall refresh

Fontes:

Renomeando fisicamente uma máquina virtual no VMware ESXi 5

Howto: Renomeando fisicamente uma máquina virtual no VMware ESXi/5x.

Ao migrar uma máquina virtual entre servidores de VMs é possível pelo vSphere renomear o nome da máquina no histórico de VMs, mas fisicamente o disco (vmdk) e outros arquivo permanecem com o nome da máquina original.

Para renomear todos os arquivos fisicamente, siga esses passos. Lembrando que a máquina virtual deve estar desligada.

1. Logue via SSH no seu servidor de VM-ESXi

# cd /vmfs/volumes/datastore1

2: Renomeie a pasta:
# mv maquina_velha maquina_nova

3: Entre na pasta renomeada
# cd maquina_nova

4: Renomeie todos os arquivos manualmente:
# mv maquina_velha.vmx maquina_nova.vmx
# mv maquina_velha.vmsd maquina_nova.vmsd
# mv maquina_velha.nvram maquina_nova.nvram
# mv maquina_velha.vmdk maquina_nova.vmdk
# mv maquina_velha-flat.vmdk maquina_nova-flat.vmdk
# mv maquina_velha.vmxf maquina_nova.vmxf

Uma observação, o arquivo .vmsd estava vazio por não ter sido feito nenhum snapshot da máquina.

5: Edite o conteúdo do arquivo .vmx, usando o vi. No exemplo abaixo usei o search and replace, bastando digitar :%s

# vi maquina_nova.vmx
:%s/maquina_velha/maquina_nova/g

6: Edite o arquivo .vmdk

# vi maquina_nova.vmdk
:%s/maquina_velha/maquina_nova/g

7: Se a máquina estiver registrada no histórico de VMs a mesma deve ser removida do registro.

# vim-cmd vmsvc/getallvms
# vim-cmd vmsvc/unregister 900

No caso o 900 ai é o Vmid, mas se a máquina ainda não tiver sido registrada pode-se pular este passo.

8: Registrando a nova máquina
# vim-cmd solo/registervm /vmfs/volumes/datastore1/maquina_nova/maquina_nova.vmx

E só. Agora é so editar a máquina_nova e definir uma interface de rede e inicializa-la.

Howto: Como encontrar todos os subdomínios de um determinado domínio?

Isso é possível utilizando Reverse DNS lookup. Embora existam alguns sites que ofereçam este recurso, você também pode fazer via script shell, veja como criar:

# vi /tmp/busca.sh

Entre com este script e salve o arquivo:

#!/bin/bash
IPPFX=$1
for i in `seq 1 255` ; do LIST="$LIST ${IPPFX}.$i" ; done
for i in $LIST ; do
 ENTRY="`host $i`"
 [ $? -ne 0 ] && continue
 ENTRY=`echo "$ENTRY" l sed -e 's/.* //' -e 's/\.$//'`
 echo -e "$i\t$ENTRY"
done

Dê permissão de execução:

# chmod 775 /tmp/busca.sh

Para usar o script você deverá entrar com o IP do domínio à verificar sem o último octeto, por exemplo, digamos que queremos saber todos os subdomínios que existem no domínio camara.gov.br (Câmara dos Deputados), primeiro devemos saber o IP do domínio:

# ping www.camara.gov.br
PING www.camara.gov.br (200.219.133.59) 56(84) bytes of data.

Com o IP em mãos (200.219.133.59) iremos nosso script, removendo o último octeto (59), ficando assim:

# ./busca.sh 200.219.133

E como resposta do comando acima temos:

200.219.133.2 2.133.219.200.in-addr.arpa domain name pointer copernico.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.5 5.133.219.200.in-addr.arpa domain name pointer aurelius.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.7 7.133.219.200.in-addr.arpa domain name pointer platao.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.9 9.133.219.200.in-addr.arpa domain name pointer perdiz2.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.17 17.133.219.200.in-addr.arpa domain name pointer lexml.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.18 18.133.219.200.in-addr.arpa domain name pointer arara.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.20 20.133.219.200.in-addr.arpa domain name pointer hypatia.camara.leg.br. l sed -e s/.* // -e s/\.$//
200.219.133.21 21.133.219.200.in-addr.arpa domain name pointer melissa.camara.leg.br. l sed -e s/.* // -e s/\.$//
200.219.133.24 24.133.219.200.in-addr.arpa domain name pointer csg.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.28 28.133.219.200.in-addr.arpa domain name pointer perdiz1.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.33 33.133.219.200.in-addr.arpa domain name pointer extranet2.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.43 43.133.219.200.in-addr.arpa domain name pointer democrito1.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.44 44.133.219.200.in-addr.arpa domain name pointer democrito2.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.47 47.133.219.200.in-addr.arpa domain name pointer harpia-vip.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.51 51.133.219.200.in-addr.arpa domain name pointer arquimedes.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.54 54.133.219.200.in-addr.arpa domain name pointer copernico.camara.gov.br. l sed -e s/.* // -e s/\.$//
200.219.133.181 181.133.219.200.in-addr.arpa domain name pointer gaturamo1.camara.gov.br. l sed -e s/.* // -e s/\.$//

legal né 🙂

Update: Pessoal que estava reclamando que o copiar e colar o código não estava funcionando, isso se deve provavelmente por que o WordPress muda algum código ASCII ao colar. De toda forma, segue um splash (imagem) do código para vocês digitarem.

Resolvendo o problema da eth0 não inicializar no Centos 6.x em VMware ESXi

Resolvendo o problema da eth0 não inicializar no Centos 6.x em VMware ESXi

Ao se instalar o CentOS mínimo ou como Server Basic em um ambiente virtual seja no Esxi ou Hiper-V, seguindo os procedimentos padrões, configurando duas placas de redes (eth0 e eth1) com ip fixo, marcando

para inicializar no boot e tudo mais, pode acontecer a placa eth0 não inicializar com o ip configurado, na verdade ao dar um ifconfig é exibido apenas:

lo        Link encap:Local Loopback
inet addr:127.0.0.1  Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING  MTU:16436  Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)

Vejamos como resolver:

Vamos criar o arquivo ifcfg-eth0 com o seguinte conteúdo abaixo:

# vi /etc/sysconfig/network-scripts/ifcfg-eth0

DEVICE=eth0
BOOTPROTO=static
ONBOOT=yes
NETWORK=192.168.1.0
NETMASK=255.255.255.0
IPADDR=192.168.1.4

Claro altere seu Gateway (NETWORK), máscara (NETMASK) e IP (IPADDR) de acordo com sua estrutura.

O CentOS trabalha com links simbólicos definir dispositivos Ethernet, então vamos continuar:

# ln /etc/sysconfig/network-scripts/ifcfg-eth0 /etc/sysconfig/networking/devices/ifcfg-eth0

# ln /etc/sysconfig/network-scripts/ifcfg-eth0 /etc/sysconfig/networking/profiles/default/ifcfg-eth0

Agora defina um hostname para seu servidor:

# hostname meuservidor.xpto.com

Edite o arquivo /etc/sysconfig/network, deixando assim:

# vi /etc/sysconfig/network

NETWORKING=yes
HOSTNAME=meuservidor.xpto.com
GATEWAY=192.168.1.1

Salve o arquivo e dê permissão 644:

# chmod 644 /etc/sysconfig/network

Reinicie o computador e quando retornar sua rede deve estar funcionando muito bem.

Aproveitando que estamos trabalhando com a rede, podemos configurar o DNS:

# vi /etc/resolv.conf

nameserver 192.168.1.1

Pronto!

Livro: Técnicas Avançadas na Administração GNU/Linux

A FTA – Free Technology Academy, lançou este excelente livro com técnicas avançadas na administração GNU/Linux.

São 545 páginas com os seguintes tópicos:

– Introdução ao sistema operacional GNU/Linux
– Migração e coexistência com sistemas não-Linux
– Ferramentas básicas para o administrador –
– O kernel
– Administração local
– Administração de rede
– Administração de servidor
– Administração de Dados
– Administração de Segurança
– Ajustes da Configuração e otimização
– Clustering

  • Authors: Remo Suppi Boldrito e Josep Jorba Esteve
  • Licença: GNU Free Documentation License, Creative Commons Attribute ShareAlike License
  • Informações: 545 páginas; 18.8 Mb
  • Idioma: inglês

    Opções de Download:
    ftacademy.org (tem que preencher um formulário)
    Download Direto

Script de Backup (dump) SVN – Subversion

Continuando a série de scripts de backup, hoje iremos ver como realizar o backup de versionamentos SVN (subversion).

Podemos começar este poste com as palavras de um sábio:

“Existem dois tipos de pessoas, aquelas que fazem backup regularmente e aquelas que nunca tiveram uma falha do disco rígido”

Existem uma série de cenários e estratégias de backup. A maioria delas sugerem uma cópia de segurança, uma vez por dia, geralmente nas primeiras horas. Este, porém, pode não funcionar bem com um ambiente com mudanças rápidas onde os dados muda várias vezes por hora. Este tipo de ambiente é geralmente em desenvolvimento de software, visto que o código pode se modificar completamente várias vezes em questão de horas, e muitas vezes um único backup diário pode não funcionar.

#!/bin/sh
################################################
#
# Backup Completo dos repositorios SVN
#
# @author Jonas Ferreira
# @email jonas [at] jf [dot] eti [dot] br
# @version v0.01
# @reldate 2012-04-09
################################################

# data
# ——————–
bakdate=$(date +%Y%m%d%H%M)
echo “——————————–”
echo “Rodando o script de Backup – SVN – $bakdate”
echo “——————————–\n”

# Local onde estao os repositorios
# —————————
svnrepos=”/srv/svnrepos”

# Local onde sera gerado o DUMP
# ————————
bakdest=”/home/username/SVN-BACKUPS”

# Local onde os dumps serao tranferidos, apos o DUMP
# —————————————-
baktousb=”/media/USB/Extra-BACKUP”

# Entrando na pasta dos repositorios
cd $svnrepos

# Certificando se tem acesso de escrita na pasta de destino
if [ -d “$bakdest” ] && [ -w “$bakdest” ] ; then

for repo in *; do
# gerando um dump para cada projeto
echo “Executando: svnadmin dump $repo > $bakdest/$repo-$bakdate.svn.dump \n”
# Finalizando o backup
svnadmin dump $repo > $bakdest/$repo-$bakdate.svn.dump

# copiando os arquivos para a unidade remota
if [ -d “$baktousb” ] && [ -w “$baktousb” ] ; then
echo “Copiando para $baktousb …\n”
cp $bakdest/$repo-$bakdate.svn.dump $baktousb
fi
done
else
echo “Nao eh possivel continuar o processo de backup”
echo “$bakdest *NAO* eh um diretorio gravavel.”
fi

# Finalizando o script de backup
echo “\n\n=================================”
echo ” – Backup Completo :-]”

Anexo aqui o script personalizado por mim, onde faz-se o backup Full e transfere-se para um servidor na rede por meio de cifs. (Servidor SVN rodando no CentOS 6.2).
Download do Script

Para restaurar o dump, é só executar:
$ svnadmin load /var/www/svn/repos < repos-backup Fontes: - Instalação do SVN no CentOS
http://www.niden.net/
(exemplos de backup incremental)
http://www.hossainkhan.info/content/shell-script-backup-all-your-svn-repositories

Scripts – Active Directory

Listar usuários do Active Directory

dsquery user -limit 1000 | dsget user -dn > C:\usuarios.txt

Lista de usuários do Active Directory, adicionando uma coluna informando se a conta esta habilitada ou não.

dsquery user -limit 0 | dsget user -dn -disabled > C:\usuarios2.txt

Fonte: http://www.msxfaq.de/tools/dsxxx.htm

Mostrar todos os usuários no Active Directory com “a senha nunca expira”:

get-aduser -filter * -properties Name, PasswordNeverExpires | where { $_.passwordNeverExpires -eq "true" } | where {$_.enabled -eq "true"} | Format-Table -Property Name, PasswordNeverExpires -AutoSize

Mostrar o último horário de login, em formato de classificação para objetos de computador:

Get-ADComputer -Filter * -Properties *  | Sort LastLogonDate | FT Name, LastLogonDate -Autosize

Mostrar a hora do último login, no formato classificado para userobjects:

Get-ADUser -Filter * -Properties *  | Sort LastLogonDate | FT Name, LastLogonDate -Autosize

Script de Backup (dump) Postgresql – Com bancos a escolher

Depois que publiquei o artigo Script de Backup (dump) Postgresql – Múltiplos bancos em arquivos separados, onde por meio de um script shell, é gerados dumps de todos os bancos existentes no servidor, cada banco um arquivo separado e compactado, me perguntaram se era possível, com a mesma idéia fazer um script que ao invés de realizar o dump de todas as bases, fosse possível definir quais bancos seriam backupiados.

Pois bem, é bem simples de fazer isso, vejamos:

#!/bin/bash
#
# Um simples script de backup
# Autor: Jonas Ferreira

# db_array - lista dos bancos que se deseja fazer o dump
db_array="banco1 banco2 banco3 banco4"

# logfile - arquivo que grava o log de cada execucao do script
logfile="/tmp/pgsql-backup.log"

#Diretorio de destino do arquivos
DIR=/tmp/backup

for db in $db_array
do
        /usr/bin/pg_dump $db > "$DIR/$db.sql" 1>> $logfile 2>> $logfile
        tar zcvf "$DIR/$db.tgz" "$DIR/$db.sql"
        rm -rf "$DIR/$db.sql"
done

Simples assim!