Gerenciamento de usuários no Linux.




Hoje vamos conhecer uma lista de comandos utilizados para gerenciamento de usuários no Linux.

Criar um novo usuário:

useradd operacional

Deletar um usuário:

userdel operacional

Criar usuário e adicionar a um grupo:

useradd operacional -g root

Definir uma senha para o usuário: 

passwd operacional

Remover expiração da conta: 

chage -E -1 operacional

Forçar usuário trocar a senha no próximo login:

chage -d 0 operacional

Mostra arquivos abertos pelo usuário:

lsof operacional

Verificar status do usuário:

passwd -S operacional

Definir que a senha do usuário expira em 30 dias:

passwd -x30 operacional

Efetuar lock de um usuário:

passwd -l operacional

Remover o lock do usuário: 

passwd -u operacional

Modificações podem ser efetuadas com o comando usermod, use usermod --help para mais informações.



Quem está logado no momento:

who 

Detalhes dos usuários logados:

who -a 

Histórico de login:

last

Usuários que tentaram logar mas não tiveram sucesso:

last b 

Mostra quando cada usuário no sistema fez login pela última vez:

lastlog 

Esses são alguns comandos utilizados no dia a dia para gerenciamento de usuário, em breve veremos mais sobre controle e permissões de usuários. 

Criando partições no Linux usando o fdisk.



Quando nos deparamos em uma situação em que não possuímos mais espaço para armazenar arquivos nas partições disponíveis, existe a necessidade de adicionar uma nova partição, vamos entender como podemos fazer isso.

Para listar os discos disponíveis, utilizamos o comandos fdisk -l.

Disk /dev/sdc: 20 GiB, 21474836480 bytes, 41943040 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 39F7EB04-5318-429F-A6BC-70BF292DDBC2

Device       Start     End Sectors Size Type
/dev/sdc1     2048 4196351 4194304   2G Linux filesystem
/dev/sdc2  4196352 8390655 4194304   2G Linux filesystem

Ao realizar o comando, encontrei o disco /dev/sdc que possui 20GB, onde podemos criar uma nova partição, vamos efetuar a criação da partição /dev/sdc3.

Para acessar as configurações deste disco utilizamos fdisk /dev/sdc.



Ao digitar m é listado todos os comandos que podemos utilizar no fdisk, vamos utilizar o comando n para criar uma nova partição.



Em partition number vamos informar o número da partição, como já existem duas partições, como default foi selecionada a partição três.

Em first sector vamos informar o primeiro setor do disco e em last sector o último, podemos definir desta forma o tamanho que sera utilizado para partição, deixando como default ele utilizara o primeiro setor e o último disponivel. Desta forma foi criada a partição 3 com 16GB.

Utilizando o comando p será listadas as partições deste disco, agora incluindo a partição 3. 

Disk /dev/sdc: 20 GiB, 21474836480 bytes, 41943040 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 39F7EB04-5318-429F-A6BC-70BF292DDBC2

Device       Start      End  Sectors Size Type
/dev/sdc1     2048  4196351  4194304   2G Linux filesystem
/dev/sdc2  4196352  8390655  4194304   2G Linux filesystem
/dev/sdc3  8390656 41943006 33552351  16G Linux filesystem

Para sair e salvas as alterações efetuadas basta utilizar o comando w, agora vamos formatar a partição no formato ext4. 

root@linux:/# mkfs -t ext4 /dev/sdc3


Você pode escolher o nome da partição que será montada, basta criar no / utilizando o comando mkdir.

root@linux:/# mkdir files
root@linux:/# mount /dev/sdc3 /files

O comando mount é usado para montar a partição dessa forma utilizando mount nome do disco e nome do diretório.
Com df -h listaremos as partições.

root@linux:/# df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1       7,3G  4,8G  2,1G  70% /
/dev/sdc3        16G   44M   15G   1% /files


Sugiro explorar o fdisk e criar novas partições, estas abaixo são comuns no Linux:

/home
/var
/tmp
/boot
/usr

Movimentar Datafiles no Oracle com a Tablespace Offline.



Existem situações em que é necessário efetuar movimentação de datafiles para liberar espaço em uma partição que esta prestes a chegar ao limite, ou até mesmo para distribuir o consumo entre as partições disponíveis no servidor.

Ao efetuar a movimentação de um datafile nenhuma alteração pode ocorrer neste, sendo assim podemos baixar o banco de dados para movimentar ou baixar a tablespace a qual este datafile pertence.

Primeiro, vamos identificar o datafile que iremos mover, neste exemplo vou efetuar a movimentação do datafile tbd_dados2.dbf da partição /u01 para partição /u02.


Antes de efetuar a movimentação, vamos identificar a qual tablespace este datafile pertence, utilizando o script abaixo:

set lines 120;
col file_name format a60
col tablespace_name format a20
SELECT file_name, tablespace_name, ROUND(bytes/1024000) MB FROM dba_data_files where file_name LIKE '%tbd_dados2.dbf%' ORDER BY 1;

Podemos ver que este datafile pertence a tablespace TBS_DADOS;




Vamos alterar agora a tablespace para offline

alter tablespace TBS_DADOS offline;

Em seguida realizar a cópia pelo S.O.

cp /u01/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf /u02/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf

Atualizamos agora o novo local do datafile no banco;

alter database rename file '/u01/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf' to '/u02/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf';

Depois de alterado no banco de dados, colocaremos a tablespace online novamente.

alter tablespace TBS_DADOS online;

Agora podemos apagar no S.O o datafile que da partição /u01.

rm -f /u01/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf


De forma simples efetuamos a movimentação de um datafile entre partições sem a necessidade de baixar o banco de dados.

Fonte: "https://docs.oracle.com/cd/B28359_01/server.111/b28310/dfiles005.htm#ADMIN11430"

Manutenção de logs e traces com ADRCI



É comum encontrar consumo excessivo de disco por conta de alta geração de traces e logs de erros no ambiente Oracle.

O ADRCI  é um repositório baseado em arquivos para dados de diagnóstico de banco de dados, tais como traces, dumps, o alert log, health monitor reports, etc.

Por padrão podemos iniciar o ADRCI acessando $ORACLE_HOME/bin e utilizando o comando ./adrci ou se as variáveis já são exportadas automaticamente ao acessar o usuário oracle, basta somente digitar adrci.





Digitando o comando show homes será apresentado todos os homes do ADR .

ADR Homes:
diag/rdbms/orcl/orcl
diag/tnslsnr/localhost/listener
diag/tnslsnr/SRVORCL/listener

Sabemos agora que estes são os diretórios onde os arquivos que queremos aplicar a retenção se encontram.

Vamos agora utilizar um script para definir a politica de retenção e excluir os arquivos: 

set HOME diag/rdbms/orcl/orcl
set control (SHORTP_POLICY = 240);
set control (LONGP_POLICY = 240);
purge -age 10080 -type ALERT
purge -age 10080 -type TRACE
purge -age 10080 -type incident
purge -age 10080 -type hm
purge -age 10080 -type utscdmp
purge -age 10080 -type cdump

Dentro do set HOME vamos definir os diretórios que foram informado em resultado ao comando show homes. 

SHORTP_POLICY é parâmetro responsável pela retenção dos arquivos de traces e o LONGP_POLICY pela retenção dos arquivos de incidentes. Os valores são definidos em horas.

O purge ira efetuar a a exclusão dos arquivos, os valores nele são definidos em minutos. 



Aprendemos hoje a realizar a retenção de arquivos de logs e traces utilizando o ADRCI, podemos utilizar esta ferramenta para gerenciar os dados de diagnósticos armazenados, vamos abordar mais sobre a ferramenta em breve.

Fonte: https://www.oracle.com/technetwork/pt/articles/database-performance/automatic-diagnostic-repository-2417674-ptb.html

Adição de Datafiles no banco de dados Oracle.


Os datafiles são estruturas físicas do banco, que estão ligados a uma unidade lógica chamada de tablespace. O crescimento dos datafiles pode ser limitado e controlado dentro do banco.

Para listar todas as tablespaces contidas no banco de dados utilizamos o seguinte script: 

set lines 158
set pages 100
column "Tablespace" format A20
column "Usado" format '9,999,990.00'
column "Livre" format '9,999,990.00'
column "Expansivel" format A12
column "Total" format '9,999,990.00'
column "Usado %" format '990.00'
column "Livre %" format '990.00'
column "Tipo Ger." format A12
select t.tablespace_name "Tablespace",
       round(ar.usado, 2) "Usado",
       round(decode(NVL2(cresc.tablespace, 0, sign(ar.Expansivel)),
                    1,
                    (ar.livre + ar.expansivel),
                    ar.livre),
             2) "Livre",
       round(ar.alocado,2) "Alocado Mb",
       NVL2(cresc.limite, 'ILIMITADO', round(ar.expansivel, 2)) "Expansivel",
       round(decode(NVL2(cresc.tablespace, 0, sign(ar.Expansivel)),
                    1,
                    ar.usado / (ar.total + ar.expansivel),
                    (ar.usado / ar.total)) * 100,
             2) "Usado %",
       round(decode(NVL2(cresc.tablespace, 0, sign(ar.Expansivel)),
                    1,
                    (ar.livre + ar.expansivel) / (ar.total + ar.expansivel),
                    (ar.livre / ar.total)) * 100,
             2) "Livre %",
       round(decode(NVL2(cresc.tablespace, 0, sign(ar.Expansivel)),
                    1,
                    (ar.total + ar.expansivel),
                    ar.total),
             2) "Total",
       t.Contents "Conteudo",
       t.Extent_Management "Tipo Ger.",
       FORCE_LOGGING
  from dba_tablespaces t,
       (select df.tablespace_name tablespace,
               sum(nvl(df.user_bytes,0))/1024/1024 Alocado,
               (sum(df.bytes) - sum(NVL(df_fs.bytes, 0))) / 1024 / 1024 Usado,
               sum(NVL(df_fs.bytes, 0)) / 1024 / 1024 Livre,
               sum(decode(df.autoextensible,
                          'YES',
                          decode(sign(df.maxbytes - df.bytes),
                                 1,
                                 df.maxbytes - df.bytes,
                                 0),
                          0)) / 1024 / 1024 Expansivel,
               sum(df.bytes) / 1024 / 1024 Total
          from dba_data_files df,
               (select tablespace_name, file_id, sum(bytes) bytes
                  from dba_free_space
                 group by tablespace_name, file_id) df_fs
         where df.tablespace_name = df_fs.tablespace_name(+)
           and df.file_id = df_fs.file_id(+)
         group by df.tablespace_name
        union
        select tf.tablespace_name tablespace,
               sum(nvl(tf.user_bytes,0))/1024/1024 Alocado,        
               sum(tf_fs.bytes_used) / 1024 / 1024 Usado,
               sum(tf_fs.bytes_free) / 1024 / 1024 Livre,
               sum(decode(tf.autoextensible,
                          'YES',
                          decode(sign(tf.maxbytes - tf.bytes),
                                 1,
                                 tf.maxbytes - tf.bytes,
                                 0),
                          0)) / 1024 / 1024 Expansivel,
               sum(tf.bytes) / 1024 / 1024 Total
          from dba_temp_files tf, V$TEMP_SPACE_HEADER tf_fs
         where tf.tablespace_name = tf_fs.tablespace_name
           and tf.file_id = tf_fs.file_id
         group by tf.tablespace_name) ar,
       (select df.tablespace_name tablespace, 'ILIMITADO' limite
          from dba_data_files df
         where df.maxbytes / 1024 / 1024 / 1024 > 30
           and df.autoextensible = 'YES'
         group by df.tablespace_name
        union
        select tf.tablespace_name tablespace, 'ILIMITADO' limite
          from dba_temp_files tf
         where tf.maxbytes / 1024 / 1024 / 1024 > 30
           and tf.autoextensible = 'YES'
         group by tf.tablespace_name) cresc
where cresc.tablespace(+) = t.tablespace_name
   and ar.tablespace(+) = t.tablespace_name
order by 1 

 /


Após a execução obtive o seguinte resultado: 




Vamos utilizar como exemplo a tablespace "TBS_DADOS". Para verificar os datafiles ligados a está tablespace executaremos o script abaixo: 

set pages 200
set lines 200
col file_name for a70
select file_name, maxbytes/1024/1024 as maxbytes, bytes/1024/1024 as bytes, autoextensible 
from dba_data_files
where tablespace_name='TBS_DADOS'

order by FILE_NAME;



Conforme retorno do script, temos somente um datafile ligado a tablespace TBS_DADOS, este datafile está localizado em /u01/app/oracle/oradata/ORCL/datafile/tbd_dados.dbf e possui 100 megabytes, podendo se estender até 200 megabytes.

Agora iremos adicionar mais um datafile seguindo os padrões do datafile anterior. É importante validar se o disco possui espaço suficiente para alocar o novo datafile.


alter tablespace TBS_DADOS add datafile '/u01/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf ' size 100m autoextend on next 100m maxsize 200m;


Se executarmos novamente o script para verificação dos datafiles, podemos validar que o novo datafile já se encontra na tablespace:



Vimos de forma bem simples, como podemos adicionar um datafile a uma tablespace, é importante efetuar este procedimento com muita atenção, pois após adicionado para realizar alterações no datafile pode exigir a parada do banco de dados, abordaremos mais sobre datafiles e tablespace nas próximas postagens.


Fonte: https://docs.oracle.com/cd/B19306_01/server.102/b14220/physical.htm

Recentes

O Blog

Bem vindo ao blog AvizDBA

Criei o blog com intuito de ajudar a todos, compartilhando minha experiência, casos do dia a dia e algumas dicas.

Espero que aproveite os posts e fique a vontade para deixar um comentário caso tenha algum dúvida ou sugestão.

Certificações