Latest Publications

Mac OS X – Dicas Para Administradores de Sistemas

Nesse post, vou indicar ou até mesmo escrever uma série de dicas com intuito de falar sobre aplicativos que uso no meu Mac que podem facilitar a vida de quem é administrador de sistemas. No mundo Windows nós temos várias opções conhecidas, porém no OS X as opções com de boa qualidade não são tão fáceis de encontrar. Algumas pessoas me pedem indicações de apps com esse objetivo, dessa forma resolvi escrever esses posts para ajudar.

Esse post “MAC OS X – Dicas Para Administradores de Sistemas” será uma espécie de índice e a medida que vou escrevendo mais posts sobre os aplicativos eu vou atualizando esse aqui fazendo referência aos posts individuais.

Qualquer dúvida, deixe um comentário.

Índice

1 – ZOC Terminal
2 – 2X Client Remote Desktop
3 - TextWrangler

 

Mac OS X – 2X Client RDP

Como administrador de sistemas Unix / Linux e também de ambientes VMware, não tenho como evitar e preciso conectar também eventualmente em servidores Windows. Eu já utilizei no Mac vários clientes de Remote Desktop para acesso remoto, inclusive da própria Microsoft, porém particularmente o que eu mais me acostumei foi um chamado 2X Client Remote Desktop.

Ele é rápido, estável e possui bons recursos, tais como:

- Gerenciamento de múltiplos servidores;
- Permite salvar as senhas para logins automáticos;
- Permite trocar conteúdo via ctr+c, cmd+v;
- Redirecionamento de dispositivos, como som, discos, etc;
- Trabalha muito bem com fullscreen e faz a troca entre as conexões rapidamente;

Múltiplos Servidores

Múltiplos Servidores

Abaixo as opções para criar uma nova conexão. Um exemplo no meu servidor de testes:

Nova conexão

Nova conexão

Compartilhando meu disco local para troca de arquivos entre as máquinas.

shared devices 1

shared devices 2

shared devices 3

O 2x Client RDP está disponível gratuitamente na própria Mac App Store:

https://itunes.apple.com/br/app/2x-client-rdp-remote-desktop/id600925318?mt=12

Se você conhecer algum outro App para RDP, deixe um comentário.

Mac OS X – ZOC Terminal

ZOC é um cliente profissional de telnet/SSH e também um emulador de terminal poderoso. Possui uma lista muito grande de emuladores de terminais e permite que você se conecte usando vários métodos de conexão, como vt102, vt220 e vários tipos de ANSI não apenas alguns como TN3270, TN5250, Wyse, TVI e Suns CDE.

Ele possui alguns recursos interessantes:

- Suporte a protocolos de transferência de arquivos, como SCP, X-, Y-, Z-modem e Kermit;
- Permite enviar comandos para todas as suas conexões abertas simultaneamente;
- Possui uma linguagem de automação de tarefas com mais de 200 comandos possíveis;
- Permite salvar suas senhas para conexões automáticas (mesmo que ele tenha que passar por algum servidor antes como gateway);
- Possui diversos tipos de configuração de layouts, alterações nas cores, fontes, tipos de teclados, atalhos, entre outros.

Essa é a cara do ZOC Terminal

Essa é a cara do ZOC Terminal

 

Customizações do ZOC

Customizações do ZOC

 

Vamos supor que você precise criar um perfil para se conectar automaticamente ao servidor SRV01 que possui o IP 192.168.1.20, porém você precisa passar pelo servidor 192.168.1.10 antes como ponte. Nesse caso, vamos em Host Directory e criaremos uma nova entrada. Depois de atribuir os títulos, tipos de conexão desejada, vá para a aba Login e coloque o usuário e senha do servidor de ponte (192.168.1.10). Em AutoLogin Sequence você irá criar as entradas para a nova conexão, usando os comandos do ZOC Terminal.

Send=ssh root@192.168.1.20 ^M
Wait=password:
Send=teste123^M

Send = Envio de comandos (a sequência ^M serve para indicar um enter, ou seja, fim da linha).
Wait= Se ele encontrar a saída configurada em Wait no shell, ele emitirá o próximo comando

Host Directory

Host Directory

Captura de Tela 2014-04-08 às 11.47.17

Captura de Tela 2014-04-08 às 11.47.43

O ZOC também permite conexões rápidas, por exemplo, estou me conectando ao meu terminal local.

Quick Connection

Quick Connection

Quick Connection

O seu grande problema é que não é gratuito, pelo contrário, é um valor considerável para um cliente de acesso remoto, porém ele é vendido direto em promoções (bundles) por aí. Basta fazer umas pesquisas que você encontra ele com preço bem mais acessível.

Configurar Interface VLAN no Red Hat / CentOS

Para configurar (“taguear”) uma VLAN numa interface no Linux, podemos usar os seguintes passos, que foram todos homologados em um Red Hat Enterprise 6.

1 – Primeiramente, garanta que o módulo responsável (802.1q) esteja carregado no Kernel, caso contrário, será necessário carregar:

[root@lab01 ~]# lsmod | grep 8021q
[root@lab01 ~]# modprobe 8021q
[root@lab01 ~]# lsmod | grep 8021q
8021q 25317 0
garp 7152 1 8021q

2 – Para que a configuração do módulo fique permanente ao boot, é necessário criar um arquivo com permissão de executável dentro do /etc/sysconfig/modules/*.modules, da seguinte forma:

# echo "modprobe 8021q" > /etc/sysconfig/modules/vlan.modules
# chmod +x /etc/sysconfig/modules/vlan.modules

3 – Vamos configurar a interface física que iremos taguear a VLAN, no meu exemplo a interface eth2 (/etc/sysconfig/network-scripts/ifcfg-eth2):

DEVICE=eth2
TYPE=Ethernet
BOOTPROTO=none
ONBOOT=yes

4 – Agora vamos configurar a interface VLAN, que deve possuir o nome da interface física acrescentando um “.” e o número da VLAN, ou seja, no meu caso vamos configurar a VLAN 250 na eth2. Dessa forma criaremos o arquivo /etc/sysconfig/network-scripts/ifcfg-eth2.250 com o seguinte conteúdo (obviamente configurando com o seu endereçamento necessário):

DEVICE=eth2.250
BOOTPROTO=none
ONBOOT=yes
IPADDR=10.0.200.10
NETMASK=255.255.255.0
USERCTL=no
VLAN=yes

Se for necessário configurar uma outra VLAN na mesma interface física, por exemplo a VLAN 190, adicione um novo arquivo chamado ifcfg-eth2.190 com os detalhes de configuração necessárias.

5 – Reinicie os serviços de redes:

# service network restart

6 – Use o comando ifconfig para confirmar as configurações e caso queira obter informações detalhadas sobre as VLANs, visualize os arquivos localizados em /proc/net/vlan:

[root@lab01 vlan]# cat /proc/net/vlan/eth2.250
eth2.250 VID: 250 REORDER_HDR: 1 dev->priv_flags: 1
 total frames received 0
 total bytes received 0
 Broadcast/Multicast Rcvd 0

total frames transmitted 12
total bytes transmitted 720
total headroom inc 0
total encap on xmit 0
Device: eth2
INGRESS priority mappings: 0:0 1:0 2:0 3:0 4:0 5:0 6:0 7:0
EGRESS priority mappings:

7 – Caso não queira reiniciar o serviço de rede para validar as configurações, ao fim de tudo você pode subir manualmente as interfaces usando:

# ifup eth2
# ifup eth2.250

Existe também o comando vconfig para gerenciar manualmente as VLANs, caso queira mais informações: man vconfig ;)

ESXi – Como Quebrar Senha de Root

Nos casos de ambientes que utilizam o ESX, o processo para quebrar a senha de root é o mesmo que nos sistemas Linux tradicionais, porém quando é utilizado ESXi, oficialmente a VMware informa nos KBs de que a quebra da senha não é suportado.

Abaixo a explicação de como reiniciar a senha no ESX e a posição oficial da VMware sobre os ESXi:

http://kb.vmware.com/kb/1317898

Como visto, é indicado a reinstalação do ESXi para reiniciar a senha. Caso você não queira reinstalar, pode seguir os passos abaixo que funcionam tranquilamente:

Inicie o servidor utilizando um live CD de alguma distribuição qualquer ou como no meu caso, iniciei usando o modo Rescue da mídia do Red Hat.

Precisamos agora montar a partição onde se encontra o arquivo state.tgz, normalmente estará na partição /dev/sda5 (utilize o fdisk -l para verificar a tabela de partição)

# fdisk -l
# mkdir /mnt/sda5
# mount /dev/sda5 /mnt/sda5

Já vi relatos de máquinas HP montarem da seguinte forma:

# mount /dev/cciss/c0d0p5 /mnt/sda5

c0d0p5: controladora 0, disco 0, partição 5

Siga os seguintes passos (precisamos abrir o arquivo shadow):

# cd /mnt/sda5
# cp state.tgz /tmp/state.tgz
# cd /tmp
# tar zxf state.tgz
# tar zxf local.tgz
# cd etc

Edite agora o arquivo shadow (vi shadow) e remova o hash da senha criptografada do root (é o segundo campo separado pelos “:”)

De:

root:$1$ywxtUqvn$9e1iXjGVd45T5IAgRxAuV.:13358:0:99999:7:::

Para:

root::13358:0:99999:7:::

Salve o arquivo shadow e vamos agora fazer o processo contrário (voltando ao tmp, copiando o arquivo alterado para o disco):

# cd ..
# tar czvf local.tgz etc
# tar czvf state.tgz local.tgz
# cp state.tgz /mnt/sda5/state.tgz
# shutdown -r now

Quando o ESXi inciar, a senha de root estará vazia!

Linux – O Que São Major e Minor Numbers

Fazendo uma pesquisa para entender a teoria do assunto, lendo documentações a respeito, cheguei a uma conclusão que compartilho aqui. Qualquer observação, deixe um comentário.

Em sistemas UNIX, todos os dispositivos de hardware são basicamente arquivos, onde eles podem ser abertos, fechados, lidos e escritos usando os mesmos comandos de sistemas que são usados para manipulação de arquivos comuns. Para escrever em um disco, você escreve em um arquivo. Para gravar backups em um dispositivo de fita (Tape), você também está escrevendo em um arquivo e assim sucessivamente. Se o arquivo que você está tentando ler ou escrever é um arquivo normal, o processo é bem simples: o arquivo é aberto e você pode ler ou gravar dados. Já se o dispositivo que você quer acessar é um arquivo de dispositivo especial, existe uma etapa que precisa ser feita pelo Kernel antes dele realmente realizar a operação de leitura ou escrita.

Um ponto fundamental para que possamos compreender os arquivos de dispositivos é que diferentes dispositivos se comportam obviamente de forma diferente, ou seja, eles possuem funções e objetivos diferentes. Claro que não há teclas em um disco e nenhum setor em um teclado, por exemplo. Dessa forma, o sistema precisa de um processo pelo qual ele possa diferenciar entre os vários tipos de dispositivos e saber exatamente como tratá-lo.

Dentro do kernel, há funções para cada um dos dispositivos que ele vai acessar. Todas essas funções e rotinas combinados de um dispositivo específico, são conhecidas como um driver. Cada dispositivo no sistema tem seu próprio driver. Dentro de cada driver existem funções que são usadas para acessar o dispositivo. Para dispositivos como discos ou terminais, o sistema tem de ser capaz de (entre outras coisas) de abrir e escrever no dispositivo, ler a partir dele e saber como fechá-lo.

O kernel não só precisa saber qual o tipo de dispositivo está sendo acessado, mas também precisa saber de qualquer informação especial para que possa gerênciá-lo, como o número da partição, se é um disco ou um terminal por exemplo, entre outros. Isso é conseguido através do major e do minor number. Todos os dispositivos controlados pelo mesmo driver tem o mesmo major number em comum. Os minor number são usados para diferenciar os dispositivos específicos em si. Uma vez que o kernel determinou o tipo de dispositivo que ele está acessando, ele determina o dispositivo físico específico, o local específico que ele está conectado e outras características de controle do dispositivo por meio de um minor number.

Vamos ver o exemplo usando dispositivos SCSI:

O formato de identificação dos discos então, é definido da seguinte forma:

/dev/sd<driver><partição>

Onde sd significa que trata-se de um dispositivo SCSI, <driver> é a letra que faz referência ao dispositivo físico e <partição> é o número da partição. Sem o número da partição estamos no referindo ao disco inteiro, ex.: /dev/sda.

O major number de todo dispositivo SCSI será sempre 8 e o minor number é sempre múltiplo de 16, começando em 0. Quando é uma partição, o minor number vai incrementando um a um a partir do minor number do disco todo. Exemplificando, observe a saída a seguir.

[fsavoia@rhel-lab ~]$ ls -l /dev/sd*
brw-rw----. 1 root disk 8, 0 Jan 12 16:02 /dev/sda
brw-rw----. 1 root disk 8, 1 Jan 12 16:02 /dev/sda1
brw-rw----. 1 root disk 8, 2 Jan 12 16:02 /dev/sda2
brw-rw----. 1 root disk 8, 16 Jan 12 16:02 /dev/sdb
brw-rw----. 1 root disk 8, 17 Jan 12 16:02 /dev/sdb1
brw-rw----. 1 root disk 8, 32 Jan 12 16:02 /dev/sdc
brw-rw----. 1 root disk 8, 33 Jan 12 16:02 /dev/sdc1
brw-rw----. 1 root disk 8, 34 Jan 12 16:02 /dev/sdc2
brw-rw----. 1 root disk 8, 48 Jan 12 16:02 /dev/sdd

Como explicado anteriormente, o major number sempre será 8 para dispositivo SCSI. Para o minor number, repare que os discos são sempre múltiplos de 16: /dev/sda (minor 0), /dev/sdb (minor 16), /dev/sdc (minor 32) e /dev/sdd (minor 48). As partição são incrementadas uma a uma: /dev/sda1 (minor 1), /dev/sda2 (minor 2), /dev/sdb1 (minor 17), /dev/sdc1 (minor 33) e /dev/sdc2 (minor 34).

Os números de major e minor vão de 0 até 2^8 (256), no caso de dispositvos SCSI (dispositivos SATA usam o mesmo driver), podemos ter até 16 dispositivos em uma única controladora SCSI, assim é feita a divisão do número total por 16, por isso observa-se os discos sempre no intervalo de 16 minors. No caso de dispositivos IDEs, somente podemos ter 4 dispositivos por controladora, assim veremos os minors dos dispositivos sempre variando no intervalo de 64 minors (256/4).

No Linux, existe o arquivo /proc/devices, que mostra a lista (separada inclusive) de arquivos de caracteres e de bloco atualmente reconhecidos pelo kernel (não inclui dispositivos em que os módulos não estão carregados).

Exemplo da saída resumida:

Character devices:
 1 mem
 4 /dev/vc/0
 4 tty
 4 ttyS
 5 /dev/tty
 5 /dev/console
 5 /dev/ptmx
 7 vcs
 10 misc
 13 input
 14 sound
 21 sg
Block devices:
 1 ramdisk
259 blkext
 7 loop
 8 sd
 9 md
 11 sr
253 device-mapper
254 mdp

Dispositivos de caracteres e de blocos são bem similares, porém tem uma diferença fundamental:

Os arquivos de caracteres não necessitam de buffer. As requisições para os dispositivos de caractere são tratadas imediatamente. Os arquivos de caracteres também enviam dados sem tamanhos pré-configurados, diferentes dos dispositivos de blocos, que podemos enviar e receber informações em blocos de tamanho configurados por dispositivo. Os dispositivos de blocos trabalham com um buffer cache disponível, permitindo que ele ordene as requisições em memória antes de endereça-las ao disco físico  efetivamente. Isso é importante para dispositivos que trabalham com armazenamento, como os discos, pois isso permite melhor performance. Os dados também podem ser acessados ramdomicamente, ou seja, qualquer bloco pode ser acessado ou escrito no importa aonde ele esteja no disco.

Se alguém quiser colocar algum ponto ou discordar de algo, fique a vontade para comentar.

HP-UX – Como Criar Filesystem Usando LVM

Nesse post, irei explicar como criar um PV, VG, LV e file system no HP-UX, ou seja, uma estrutura completa. Irei usar como exemplo dois discos de 50GB: /dev/dsk/c1t0d0 e /dev/dsk/c1t2d0. Vamos montar esse filesystem de 100GB dentro de /exemplo.

1 – Primeiro, vamos iniciar o disco criando o PV. Esse comando deve ser executado no arquivo de disco RAW (rdsk):

# pvcreate /dev/rdsk/c1t0d0
 Physical volume "/dev/rdsk/c1t0d0" has been successfully created.
# pvcreate /dev/rdsk/c1t2d0
 Physical volume "/dev/rdsk/c1t2d0" has been successfully created.

2 – Agora é hora de criarmos o volume group. Quando criamos um VG no HP-UX, precisamos manualmente criar o arquivo de caractere especial chamado group. O comando que usamos para isso é o mknod. Vamos ver abaixo e depois a explicação:

# mkdir /dev/vgExemplo
# mknod /dev/vgExemplo/group c 64 0x010000

Onde:

c: Indica que o arquivo group é arquivo de caractere
64: É o major number do arquivo group. Será sempre 64, pois 64 é a referência para o driver LVM no sistema.
0xNN0000: É o minor number em hexadecimal e o NN é o número de identificação do VG. Esse número deve ser único e obviamente diferente de todo os outros VGs no sistema. Esse NN pode variar de 00 até ff (segundo manual do HP-UX). O valor máximo do NN é controlado pelo parâmetro de tuning do kernel chamado maxvgs.

Usando o comando abaixo você pode ver esses números de identificação para criar o seu VG. Eu criei na sequencia usando 01, você pode fazer o mesmo. Perceba os números que acabamos de criar para os arquivos de caractere:

# ls -ltr /dev/*/group
 crw-r----- 1 root sys 64 0x000000 Jun 5 2013 /dev/vg00/group
 crw-r--r-- 1 root sys 64 0x010000 Jan 12 10:50 /dev/vgExemplo/group
# vgcreate -s 16 /dev/vgExemplo /dev/dsk/c1t0d0 /dev/dsk/c1t2d0
 Increased the number of physical extents per physical volume to  19199.
 Volume group "/dev/vgExemplo" has been successfully created.
 Volume Group configuration for /dev/vgExemplo has been saved in /etc/lvmconf/vgExemplo.conf

Consulte o manual do comando vgcreate para obter detalhes de opções possíveis. Nesse caso usei o “-s 16″ para alterar o tamanho padrão do PE (Physical Extent) de 4MB para 16MB.

3 – Vamos criar um LV usando o tamanho total disponível no nosso VG:

Primeiro, consulte com o comando vgdisplay vgExemplo para identificarmos o valor livre que temos (Free PE x PE Size):

# vgdisplay /dev/vgExemplo
--- Volume groups ---
VG Name /dev/vgExemplo
VG Write Access read/write
VG Status available
Max LV 255
Cur LV 0
Open LV 0
Max PV 16
Cur PV 2
Act PV 2
Max PE per PV 3200
VGDA 4
PE Size (Mbytes) 16
Total PE 6400
Alloc PE 6400
Free PE 6400
Total PVG 0
Total Spare PVs 0
Total Spare PVs in use 0

Vamos criar o LV usando todo espaço com o comando lvcreate. Esse comando aceita os parâmetros -L, onde colocamos o valor em MB,  ou -l, onde colocamos o valor em PEs. O parâmetro -n serve para definição do nome do LV:

# lvcreate -l 6400 -n lv_exemplo /dev/vgExemplo
Logical volume "/dev/vgExemplo/lv_exemplo" has been successfully created with
character device "/dev/vgExemplo/rlv_exemplo".
Logical volume "/dev/vgExemplo/lv_exemplo" has been successfully extended.
Volume Group configuration for /dev/vgExemplo has been saved in /etc/lvmconf/vgExemplo.conf

4 – Hora da criação do filesystem.

Parar criarmos o filesystem usamos o comando newfs no arquivo raw (rlv) do logical volume:

# newfs -F vxfs -o largefiles /dev/vgExemplo/rlv_exemplo
 version 5 layout
104841216 sectors, 104841216 blocks of size 1024, log size 16384 blocks
 unlimited inodes, largefiles supported
104841216 data blocks, 104841216 free data blocks
 63990 allocation units of 32768 blocks, 32768 data blocks

Onde:

-F vxfs: Define o tipo de filesystem, nesse caso vamos usar o padrão vxfs
-o largefiles: Habilita suporte para largefiles no filesystem. Por padrão, o maior arquivo que podemos gravar é de 2GB. Como nosso filesystem de exemplo tem 100GB, vamos usar o largefiles. Eu aconselho a sempre usá-lo quando você tiver filesystems com 2GB ou mais.

5 – Vamos criar o ponto de montagem e ajustar o arquivo /etc/fstab para ficar persistente no boot.

Linha do arquivo fstab:

/dev/vgExemplo/lv_exemplo /exemplo vxfs largefiles 0 2

Hora de montar e conferir se o filesystem foi criado com sucesso:

# mkdir /exemplo
# mount /exemplo
# bdf /exemplo
Filesystem       kbytes   used  avail   %used Mounted on
/dev/vgExemplo/lv_exemplo
                104841216 26520 104814696 0% /exemplo

Linux – Reduzir Filesystem Usando LVM

Para diminuir um file system que esteja usando LVM no Linux, você pode seguir os passos abaixo. Um aviso importante: Garanta um backup íntegro antes do procedimento, pois embora seja um procedimento simples, ele também é relativamente arriscado, caso você cometa algum pequeno erro no processo ou algo do gênero:

1 – Desmonte o filesystem, por exemplo:

# umount /u01

2 – Rode um fsck para checar a integridade do filesystem antes de realizar o procedimento, evitando assim surpresas:

# fsck –f /dev/vgoracle/u01

3 – Redimensione o filesystem primeiro, antes de reduzir o volume lógico, no exemplo abaixo estamos reduzindo o filesystem para 1G. Importante que esse passo seja feito primeiro e com muito cuidado:

resize2fs -p /dev/vgoracle/u01 1G

4 – Redimensione agora o LV (volume lógico):

lvreduce –L 1G /dev/vgoracle/u01

A opção -L do lvreduce indica que iremos colocar o valor final que o filesystem irá ficar no formato: <tamanho><k|m|g|t>, ou seja, no caso acima diretamente em Giga.

Veja na prática:

Exemplo de uso do lvreduce

Exemplo de uso do lvreduce

Remontando e testando o novo tamanho

Remontando e testando o novo tamanho

VMware – Desabilitar Mensagens de Warning SSH

Ok, o site é sim focado em Unix / Linux, mas vamos hoje falar sobre VMware :P

Uma dica: Quando ativamos SSH no VMware ESXi, ele automaticamente gera um alerta da seguinte forma no vCenter:

Configuration Issues
 ESXi Shell for the host has been enabled
 SSH for the host has been enabled

Para desabilitar esse alarme, clique no seu host e siga o caminho abaixo:

Configuration -> Advanced Settings -> UserVars -> SupressShellWarning -> 1 -> OK

Dicas LPIC-3 Core

Olá pessoal!

Em 2008 quando fui aprovado para LPIC-2, não tinha mais intenção de realizar o exame para a LPIC-3, porém como minha certificação estava para expirar agora no meio do ano, decidi então estudar um pouco e realizar a prova 117-301 para não perder a certificação. Fiz a prova ontem e fui aprovado com 760 pontos (dos 800).

Esse é a prova core da LPIC-3. Diferente dos outros níveis, para se tornar LPIC-3 basta ser aprovado em apenas uma prova e posteriormente, você pode optar pelas outras provas de especialização dentro da LPIC-3, como pode ser visto no site oficial: http://www.lpi.org/linux-certifications/programs/lpic-3.

Bom, aqui vão algumas dicas:

20% da minha prova abordou o tema Capacity Planning, porém como ela possui peso máximo, é necessário que você estude bem esse tema. Como isso é basicamente meu dia a dia, eu apenas dei uma reforçada para a hora da prova. Nesse excelente artigo em português da Oracle, somado com esse artigo em inglês da IBM, cobre 100% do conteúdo, estude e pratique esse tema.

http://www.oracle.com/technetwork/pt/articles/linux/part3-087826-ptb.html

http://www.ibm.com/developerworks/linux/tutorials/l-lpic3306/

Para conteúdo sobre LDAP, eu li o livro “LDAP Administração de Sistemas” em português mesmo (boa tradução), do autor Gerald Carter (O’Reilly / AltaBooks). Esse livro cobre quase 100% da prova, acredito que ele só não aborde “syncrepl”, porém você pode complementar seus estudos lendo alguns artigos online, principalmente esse feito pela IBM, focado na prova.

IBM Technical library LPIC-3

Eu montei 3 máquinas virtuais, nas quais eu testei instalação, replicação com Slurpd (cai bastante na prova) e syncrepl (usado atualmente). Fiz testes de autenticação, integração com NIS, Samba, entre outros. Pratiquei também os diversos comandos cobrados na prova: ldapsearch, ldapadd, slapadd, slapcat, slaptest, ldapmodify, entre outros. E é claro, estudei bem os conceitos.

Qualquer coisa, comente aí..