Archives mensuelles : juin 2018

[Ansible] : Récupérer un rôle de Galaxy

Petit à petit je me met à Ansible et ça commence à devenir sympa. Et pour bien avancer et pas réinventer les choses, je vous recommande de vous rendre sur le site Galaxy. Il héberge les rôles partagés par la communauté.

person sky silhouette night

Photo by Snapwire on Pexels.com

Bien sûr il y a à boire et à manger. Il faut faire le tri pour trouver une chaussure à votre pied. Trouver le bon OS, voir le nombre de téléchargement etc… Mais ça vaut le coup car il y a vraiment beaucoup de rôles disponibles.

Mais comment récupérer un rôle de galaxy ?

Dans un premier temps on aurait tendance à faire avec la commande :

ansible-galaxy install -p roles username.role_name

L’option « p » permet d’indiquer le chemin où déposer le rôle.

Mais que se passe-til si vous devez retélécharger le rôle quelques moi splutard et que vous n’avez pas conservé votre ligne de commande ? plus rien

Donc le mieux, c’est de stocker ça dans un fichier pour relancer en tant que de besoin. Ne serait-ce que pour faire un upgrade.

Et là la commande idéale c’est :

ansible-galaxy install -v -p roles -r requirements.yml

L’option « r » pointe vers le fichier qui contient l’auteur et le nom du rôle sous cette forme:

- src: geerlingguy.postgresql
  name: postgres_server

Et voilà le tour est joué.

PS : n’oubliez pas d’exporter vos variables de proxy si vous êtes derrière un proxy.

#Devdocs.io : retrouver les docs des principaux outils et languages

Là c’est du lourd. C’est vrai que tout le monde rêve d’avoir un outil qui regroupe tous les languages et les outils du développeurs (web ou autres). Bon on en est pas loin du tout avec https://devdocs.io/.

Sur ce site vous retrouverez de très nombreux languages :

  • perl
  • ruby
  • python
  • c
  • c#
  • etc…

Des docs sur des outils courants :

  • postgres
  • ansible
  • http
  • apache
  • cake
  • node.js

En plus grâce à son usage du cache de navigateur, il permet de faire du offline.

batch books document education

Photo by Pixabay on Pexels.com

[Python] : lancer un serveur web en une ligne

Python comme quelques autres languages permettent de faire simplement des tâches qui peuvent paraître parfois « un peu lourdes ». Attention quand je dis des tâches ce ne sont pas non plus des choses insurmontables mais plutôt des choses où on pense qu’il faut une trentaine de lignes pour faire ça.

python book

Photo by Christina Morillo on Pexels.com

Là aujourd’hui je découvre un truc tout simple, le lancement d’un serveur web. D’habitude il faut faire appelle à des sockets… Et bien là c’est simplement unte toute petite ligne.

#en python 3
python3 -m http.server

#en python 2
python -m SimpleHTTPServer 8000

Et àla vous pouvez lancer votre navigateur sur localhost:8000 et vous découvrez le répertoire là où vous avez lancé la commande.

Ce n’est pas exceptionnel mais c’est tellement simple.

[TIPS] : Remplacer un pattern dans plusieurs fichiers

Cela arrive souvent sur Linux on vous file un tar.gz avec des chemins à modifier mais qui ne sont pas passés par une variable. Résultat il faut se palucher plusieurs fichier à modifier à la main.

Ben non bien sûr ! sur linux on peut faire cela plus facilement !

Découvrez cette astuce en vidéo :

Un bon grep suivi d’un xargs et le tour est joué :

grep -Rl '/home/titi' * | xargs sed -i -e 's#/home/titi#/home/toto/appli1#g'

Dans cet exemple, on liste tous les fichiers qui contiennent « /home/titi » et on leur applique un sed où on remplace « /home/titi » par « /home/toto/appli1 ». et voilà le tour est joué. L’option s de sed permet de remplacer et l’option g permet de ne pas limiter le remplacement à une substitution mais bien à l’ensemble du fichier.

[Oracle] : Lister nombre de connexion/processus pour une instance

Comment lister le nombre de connexion via le nombre de processus ? c’est assez simple si l’on est hors pooler de connexion. Pour le suivre dans le temps (par exemple toutes les 5 minutes).

#!/bin/bash

while true
do
t=$(date)
ps=$(ps auxwww | grep nominstance |grep -v ora_ | wc -l)
echo $ps
echo $t' --> '$ps >> verif.log
sleep 5m
done

Vous remarquerez que par la boucle while = true on se passe de faire un cron en donnant par exemple un sleep de 5 minutes (on attend 5 minutes pour relancer le script).

Si vous voulez le lancer indéfiniment, il suffit de le mettre dans un fichier qui sera lancé via un nohup.

[Ansible] : Find lister des fichiers et réaliser une action dessus

Ansible est nouveau pour moi donc vous devriez trouver dans les prochains jours pas mal de tips pour réaliser de petites actions avec ansible.

Aujourd’hui je cherche à lister les fichier d’un répertoire et à réaliser dessus une action. Dans mon cas je vais créer des liens symboliques pour faire en sorte que les binaires oracle soient directement accessible via /usr/bin (dans le path des users). On aurait aussi pu supprimer des fichiers ou autres.

tasks:
  - name: Liste les binaires oracle
    find:
      paths: /usr/lib/oracle/12.2/client64/bin/
    register: result
  - name: Création des liens symboliques
    file:
      src: "{{ item.path }}" 
      dest: /usr/bin/{{ item.path | basename }}
      state: link
    with_items: "{{ result.files }}" 

On met donc la liste des fichiers dans la variable « result ». Il s’agit d’un tableau. Si vous voulez aller plus loin vous pouvez vous référer à la doc sur le module find pour utiliser d’autres éléments du tableau.

Ensuite, on parcourt chaque file avec le with_items. On utilise alors item.path pour récupérer le chemin en dur. Pour la destination on lui applique la commande basename pour récupérer uniquement le nom de fichier.

Au passage j’ai découvert un blog ansible sympa… mais peut être un peu court.

[Oracle] : suivre l’utilisation du tablepace temporaire

Hé ! un petit coup de DBA pour ce nouvel article, penchons nous sur oracle. Si vous voulez découvrir mes autres articles oracle, rendez-vous sur cette page. Le tablespace temporaire permet de faire des opération volumineuse principalement les tris. Le problème c’est de dimensionner ce TEMP de manière suffisament importante sans trop que celui-ci ne prenne de place. Si celui-ci est trop important cela peut aussi signifier une mauvaise utilisation du moteur (mauvais modèle de base de données par exemple ou mauvaises requêtes).

Un élément important pour savoir si celui-ci est assez grand c’est de connaître son utilisation. Le problème c’est que si on réalise une qequête standard pour suivre les tablespaces on tombe sur le HWM « High Water Mark ». Et comme souvent son utilisation a déjà atteint 100%, on ne sait pas son utilisation réelle.

Donc voici la requête qui vous permet de connaître son niveau à un instant T :

echo '
set lines 120;
set pages 999;
set FEEDBACK OFF;
set HEADING OFF;
SELECT   A.tablespace_name tablespace, D.mb_total,
SUM (A.used_blocks * D.block_size) / 1024 / 1024 mb_used,
D.mb_total - SUM (A.used_blocks * D.block_size) / 1024 / 1024 mb_free
FROM     v$sort_segment A,
(
SELECT   B.name, C.block_size, SUM (C.bytes) / 1024 / 1024 mb_total
FROM     v$tablespace B, v$tempfile C
WHERE    B.ts#= C.ts#
GROUP BY B.name, C.block_size
) D
WHERE    A.tablespace_name = D.name
GROUP by A.tablespace_name, D.mb_total;
'|sqlplus -S '/ as sysdba'

Vous pouvez ensuite placer ce code et le logger dans un cron ou encore mettre un watch et manger du pop-corn lol !

Pour être plus complet sur le suivi de cette thématique, voici ci-dessous un ensemble de requêtes très utiles :

  • utilisation du tablespace TEMP,
  • users et requête dans le TEMP,
  • requête en cours sur le moteur
col sid_serial format a10
col username format a17
col osuser format a15
col spid format 99999
col module format a15
col program format a30
col mb_used format 999999.999
col mb_total format 999999.999
col tablespace format a15
col statements format 999
col hash_value format 99999999999
col sql_text format a50
col service_name format a15

prompt 
prompt #####################################################################
prompt #######################LOCAL TEMP USAGE#############################
prompt #####################################################################
prompt 

 SELECT   A.tablespace_name tablespace, D.mb_total,
SUM (A.used_blocks * D.block_size) / 1024 / 1024 mb_used,
D.mb_total - SUM (A.used_blocks * D.block_size) / 1024 / 1024 mb_free
FROM     v$sort_segment A,
(
SELECT   B.name, C.block_size, SUM (C.bytes) / 1024 / 1024 mb_total
FROM     v$tablespace B, v$tempfile C
WHERE    B.ts#= C.ts#
GROUP BY B.name, C.block_size
) D
WHERE    A.tablespace_name = D.name
GROUP by A.tablespace_name, D.mb_total;

prompt 
prompt #####################################################################
prompt #######################LOCAL TEMP USERS#############################
prompt #####################################################################
prompt 

SELECT   S.sid || ',' || S.serial# sid_serial, S.username, S.osuser, P.spid, 
--S.module,
--P.program,
s.service_name,
SUM (T.blocks) * TBS.block_size / 1024 / 1024 mb_used, T.tablespace,
COUNT(*) statements
FROM     v$tempseg_usage T, v$session S, dba_tablespaces TBS, v$process P
WHERE    T.session_addr = S.saddr
AND      S.paddr = P.addr
AND      T.tablespace = TBS.tablespace_name
GROUP BY S.sid, S.serial#, S.username, S.osuser, P.spid, 
S.module,
P.program,
s.service_name,TBS.block_size, T.tablespace
ORDER BY mb_used;

--prompt 
--prompt #####################################################################
--prompt #######################LOCAL ACTIVE SQLS ############################
--prompt #####################################################################
--prompt 
--
SELECT sysdate "TIME_STAMP", vsu.username, vs.sid, vp.spid, vs.sql_id, vst.sql_text,vsu.segtype, vsu.tablespace,vs.service_name,
        sum_blocks*dt.block_size/1024/1024 usage_mb
    FROM
    (
            SELECT username, sqladdr, sqlhash, sql_id, tablespace, segtype,session_addr,
                 sum(blocks) sum_blocks
            FROM v$tempseg_usage
        group by  username, sqladdr, sqlhash, sql_id, tablespace, segtype,session_addr
    ) "VSU",
    v$sqltext vst,
    v$session vs,
    v$process vp,
    dba_tablespaces dt
 WHERE vs.sql_id = vst.sql_id
    AND vsu.session_addr = vs.saddr
    AND vs.paddr = vp.addr
    AND vst.piece = 0
    AND vs.status='ACTIVE'
    AND dt.tablespace_name = vsu.tablespace
 order by usage_mb;
--
--prompt 
--prompt #####################################################################
--prompt #######################LOCAL TEMP SQLS##############################
--prompt #####################################################################
--prompt 
SELECT  S.sid || ',' || S.serial# sid_serial, S.username, Q.sql_id, Q.sql_text,
T.blocks * TBS.block_size / 1024 / 1024 mb_used, T.tablespace
FROM    v$tempseg_usage T, v$session S, v$sqlarea Q, dba_tablespaces TBS
WHERE   T.session_addr = S.saddr
AND     T.sqladdr = Q.address
AND     T.tablespace = TBS.tablespace_name
ORDER BY mb_used;
--
--

[TIPS] : Passer une variable dans ssh

Facile certains diront mais bon il existe différentes méthode de faire. Perso je suis adepte de la méthode par export de la variable d’environnement. Mais encore il y a quelques subtilités.

Alors comme c’est mon sujet du moment, voici comment passer une commande docker en ssh :

export LC_VALEUR=$VALEUR;
export LC_DATE=$DATE;

ssh -t ${IP_WORKER} -o SendEnv=LC_VALEUR -o SendEnv=LC_DATE 
-C "echo $LC_VALEUR;
CONTENEUR_ID=\$(docker ps --filter 'name=$LC_VALEUR' 
--format '{{ .ID }}');
docker exec -i \$CONTENEUR_ID mysql -u<user> -p<password> 
< /dumps/$LC_VALEUR/$LC_DATE.$LC_VALEUR.sql;" 
| tee -a ${LOGFILE}

Alors dans cette petite ligne de commande on trouve :

  • le passage des variables d’environnements VALEUR et DATE grâce à « -o SendEnv=xxx »
  • l’utilisation de variables locales qui nécessitent du coup d’échapper le caractère $
  • on combine un docker ps avec un docker exec via ssh et ça marche bien
  • et bien sûr le -C pour exécuter une commande en ssh

Mais comment faire pour logger tout cela? Pas si simple de récupérer la sortie d’erreur ou la stdout car il faut passer par la commande tee -a (option append pour ajouter la ligne dans le fichier.

N’oublions pas l’option -t pour préciser tty sinon on génère unne erreur ssh.

Vous le voyez ce petit bout de ligne verrait bien sa place dans un script de restauration dans un cluster swarm…. on reviendra sur cela un autre jour.

[Docker] : Swarm – lister les services et les nodes en 1 ligne

Là c’est pas bien compliqué. Mais bon comme j’en ai marre de commencer par chercher les ID des service pour pouvoir faire un docker ps dessus, je me suis créé un alias qui fait le taff.

Vous êtes pas obligé d’ajouter ça dans votre bashrc mais je vous le recommande pour plus de faciliter.

En gros on combine un docker service ls et un docker service ps :

alias dserv='for id in $(docker service ls --format "{{.ID}}");do docker service ps $id;done'

Je pense que vous devez avoir aussi vos petites astuces de ce genre. N’hésitez pas à les laisser en commentaire.

[TIPS] – Tabuler ou indenter plusieurs lignes sur VIM

Certains savent le faire certainement mais perso je ne savais pas quel raccourcis utiliser. C’est vrai que tabuler à la main c’est bin mais lorsqu’il faut le faire pour une centaine de ligne… c’est chiant faut bien le dire.

Du coup voici comment faire :

On tape le chiffre du nombre de ligne à indenter suivi de >> soit deux fois la touche ‘>’.

Pour le faire avec les numéros de ligne c’est aussi simple :

:34,36>>

Et on tabule de la ligne 34 à la ligne 36.

C’est aussi valable pour les suppression avec la touche d ou avec y pour copier.

Vim c’est vraiment bien.