DevNet on Cisco Redes

BLOG – Resumo DevNet Create 2020 – Informações

Tue, 13 Oct 2020 00:00:00 +0000

Olá Pessoal,

Como todos sabem hoje ocorreu o DevNet Create 2020, onde tivemos diversas palestras atendendo as 3 regiões com seus horários distintos e com conteúdo diferenciados, para que de alguma forma pudesse atender os diferentes públicos ( iniciantes à experts ).

Baseado nesses tópicos gostaria de compartilhar algumas informações que foram capturadas durante o evento. Como em todo evento o Keynote sempre traz os principais peers dentro daquele contexto, como ocorreu nos anos anteriores temos também a participação do CEO ( Chuck Robbins ) junto com SVP and GM of Devnet ( Susie Wee ).

Informações

Diversas informações e novidades foram compartilhadas no Keynote, devido a isso resolvi condensar nesse post para ajudar à todos com esses caminhos e possibilidades.

Nesta perspectiva temos diversos Laboratórios adicionais que estão populados no portal, na qual iremos ter mais possiblidades para fazer praticas e utilizar cada vez mais a estrutura de Sandbox. Isso atender para diferentes áreas e sabores, como abaixo:

Após isso temos 3 torres que foram mencionados especificamente, onde cada um pode seguir para avaliar e obviamente agregar os tópicos para cada certificação. Segue as informações:

1. Labs SDWAN: developer.cisco.com/sdwan

Labs Security: developer.cisco.com/security

Labs Datacenter NXOS: developer.cisco.com/nexusapi

Certificações e Estudos

Temos também um resumo sobre todas as certificações e suas respectivas torres de tecnologias relacionadas para cada certificação, e podemos dizer que temos um longo trabalho e muitos estudos que podemos seguir. Isso de fato não é novidades para nós, mas sabemos que sempre precisamos estar se atualizando a cada dia. Sempre gosto de reforçar que de fato você não precisa ser um programador nativo, mas precisa ter alguns caminhos para criar suas facilidades e integrações que podem facilitar em seu dia a dia. Segue abaixo a informação resumida:

Uma outra nova notificação apresentada, esta relacionado com a capacitação dedicada a times ou parceiros queiram obter treinamentos mais direcionados, sendo ofertados pelo DevNet. Esse programa esta relacionado ao DevNet Automation Bootcamp ( cs.co/AutomationBootcamp ) onde é preenchido um formulário baseado em seu interessse. Segue a informação abaixo, bem como um link para obter mais informações ( https://developer.cisco.com/automation-bootcamp/ )

Um outro programa que vai atrelar seria o “ Class of 2020 “, onde esta relacionado a grupos de estudos para obter maiores conhecimentos, obviamente impulsionar seus estudos para suas certificações. Segue o link ( https://developer.cisco.com/classof2020/ )

Desconto nas Certificações

Agora uma das informações publicadas e podem ajudar você, onde já está estudando para sua certificação DevNet e tem planejamento para executar nos próximos meses será fantástico, pois terá um desconto de 25% no agendamento de sua prova. Porém, preste atenção, pois precisa fazer o registro entre o dia 13 à 23, onde o desconto aplicada para quem executar o exame de 26 de Outubro à 6 de Novembro de 2020.

Vale lembrar, que os exames ainda podem ser executados remotamente e todos eles são agendados através do Parceiro VUE. Para isso você deve acessar o website do DevNet ( cs.co/create2020offer ).

Comunidade DevNet

Para finalizar foi apresentado alguns números relacionados a comunidade e ao crescimento.

Conclusão

Enfim, tentei resumir um pouco das informações que capturei neste dia, obviamente mais informações estão sendo populadas no website e outros caminhos para execução desses laboratório, estudos, aprendizagem, etc.

Se você tem mais informações e gostaria de divulgar deixe seu comentário.

Abs,
Rodrigo

BLOG – DevNet Create 2020 – Participe!!

Mon, 12 Oct 2020 00:00:00 +0000

Olá Pessoal,

Não sei se todos me seguem em alguma de nossas mídias, entretanto acredito que vale a pena reforçar em um post para que todos possa saber e obviamente participar.

No dia 13 de Outubro inicia-se o DevNet Create, que terá sua cobertura sendo atendida em suas 3 regiões com horários distintos de término, isso deve-se com o intuito de atender de forma mais ampla cada indivíduo espalhando pelo mundo. 🙂

Gostaria também divulgar um video que gravei junto com a Silvia Spiva – Engagement Leader Devnet, para atingir essa fatia brasileira e trazer cada vez mais Engenheiros, Programadores e Exploradores para esse mundo, que hoje tem a intenção de agregar entre áreas de desenvolvimento, automação de redes, segurança, colaboração, etc.

Antes que vocês fiquem preocupados ou imaginem que virei um programador, isso de fato é mentira a ideia é que consigamos fazer algum processo automatizado para nosso dia a dia, entretanto não existe a necessidade de você ser um programador nativo.

Segue a chamada que gravei para publicar o evento e incentivar nossas comunidades, bem como para pensar nesses caminhos.

Agenda

Teremos 4 canais que estarão acontecendo ao mesmo tempo, e dentro deles você pode verificar qual apresentação se encaixa mais em seu perfil. Esses canais estão divididos entre:

DevNet Create\
Creators\
APIs in Action\
Start Now

Após isso, você pode adicionar em sua agenda e participar de cada um em seu respectivo horário. Eu estarei acompanhando mais agenda da região AMER que está relacionado ao timezone PDT, e que na minha situação se enquadra melhor.

Inscrição

Como todos já puderam observar esse ano o evento será online e FREE, o que acaba dando uma oportunidade ainda maior à todos participarem de sua própria casa em seu conforto, sem ter um gasto adicional.

Para isso recomendo fazer o cadastro do DevNet Create 2020 o quanto antes e já verificar sua agenda.

Espero todos lá!

Abraços,
Rodrigo

BLOG – Cisco Cert Insiders – Fóruns e Desafios = Prêmios

Tue, 16 Jul 2019 00:00:00 +0000

Olá Pessoal,

Gostaria de passar um dica rápida para vocês sobre um site da Cisco denominado como ” Cisco Cert Insiders “, onde ele esta atrelado a um fórum de discussão, bem como existe alguns desafios e informações adicionais que você pode participar e acumular pontos durante sua trajetória.

Esses desafios estão relacionados a revisões de conteúdo ( Routing, Switching, Security, etc ) atrelados algumas vezes as provas da Cisco, como também dicas sobre os conteúdos de modo geral ( DevNet, Noticias Cisco, etc ).

Como mencionado você acumula pontos que posteriormente podem ser trocados com ” presentinhos “. 🙂

Para participar você precisa ter seu CSCO, ou se desejar pode criar também através do site. Lembrando que hoje a plataforma Cisco de Autenticação está unificada para todos os acessos.

Para acessar a plataforma vá ao site Cisco Cert Insiders e aproveite!!!

Espero que tenham gostado da dica e compartilhe com seus amigo.

Abs,
Rodrigo

Ansible – Script Configuração usando Jinja2 – Parte 2

Tue, 13 Mar 2018 00:00:00 +0000

Olá Pessoal,

Vamos continuar nossas explicações sobre as configurações ( scripts ) que podemos fazer através de uma base externa ( csv ) que iniciamos em nosso post anterior.

Muitas pessoas mencionaram que de fato isso poderia ser feito através de um arquivo ( yaml ) ou propriamente sendo populado através de outra metodologia via ( group_vars ). Concordo, mas lembre-se, que eu havia mencionado que baseado em nossa estrutura de pastas vocês vão entender até nosso ultimo post as opções que teremos para trabalhar dessa forma.

Como proposto vou trazer nossa variável ” vars_dict ” para nossa pasta ( group_vars/all.yml ) adicionando ela dentro de outra variável ( vars_from_csv ), para que de fato possamos utiliza-lá fazendo referências dentro de nosso script de configuração.

---
vars_from_csv: "{{ vars_dict }}"

Como demostrado nesse momento já temos todos os nossos valores ( variáveis ) populadas, portanto, precisamos executar agora nosso template que irá capturar essas variáveis para inserir em nosso arquivo de configuração.

Dentro desse conceito “ DEVOPS “, bem como para utilização com Ansible, umas das linguagens mais utilizadas para essas demandas é chamada de JINJA2. Se vocês observarem a documentação ela também é utilizada como template para Python, portanto, desta forma você pode entender o porque da utilização nesse mundo de automação.

Sua documentação é bem extensa, mas gostaria de deixar documentado em nosso BLOG os principais ítens, que nesse primeiro momento seria para criar nosso arquivo de configuração. Eles estão relacionados aos loops e variáveis que temos que criar para utilizar em nossos equipamentos.

{% … %} for Statements

{{ … }} for Expressions to print to the template output

{# … #} for Comments not included in the template output

… ## for Line Statements

Para execução de nosso template iremos adicionar em nossa playbook inicial uma ” role ” relacionado as tarefas que iremos executar para obter o jinja ( .j2 ).

---
- name: JINJA AND CSVFILE
  hosts: all
  gather_facts: no
  connection: local

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: LOOKUP IN CSV FILE
    include_role:
      name: lookup_csv_info
    when: ./excel/test.csv is defined

  - name: EXECUTE JINJA2
    include_role:
      name: script_jinja2

Após esse processo vamos construir nossa task via ” template “, onde nosso arquivo de origem será ( .j2 ) transformando ele um arquivo destino ( .conf ) que será posteriormente arquivo para executar em nossos equipamentos da infra-estrutura. Segue task do template:

---
- name: TEMPLATE
  template:
    src: ./template/script.j2
    dest: ./template/configuration/script_{{ inventory_hostname }}.conf
  with_items: "{{ inventory_hostname }}"

Como observado precisamos agora ter nosso ” script.j2 ” construido, onde será ele o criador da configuração utilizando nossas variáveis capturadas anteriormente.

!
hostname {{ vars_from_csv.new_hostname }}
!
{% if vars_from_csv.DHCP == 'true' %}
no ip dhcp conflict logging
ip dhcp excluded-address {{vars_from_csv.dhcp_exclude1_start}} {{vars_from_csv.dhcp_exclude1_end}}
!
ip dhcp pool POOL1
   network {{vars_from_csv.dhcp_network}} {{vars_from_csv.dhcp_netmask}}
   default-router {{vars_from_csv.dhcp_gateway}}
   dns-server 8.8.8.8 8.8.4.4
{% endif %}
!
interface loopback {{ vars_from_csv.id_loopback }}
 description + Management +
 ip address {{ vars_from_csv.ip_loopback }} {{ vars_from_csv.mask_loopback }}
 no shutdown
!

De fato o que podemos entender com essa metodologia é que podemos fazer ” loops ” e a utilização de condicionais “ if ” para que se tivermos um valor ( ” true/false ” ou ” 1/0 “ ) eu posso tomar algumas decisões nessa configuração. Observem que estou colocando como exemplo a variável “ DHCP ” sendo verdadeira ( ” true ” ), que por consequência eu preciso implementar o DHCP, caso contrário eu não desejo implementar esse recurso em meus roteadores.

Com isso conseguimos observar que as alterações foram executadas utilizando nosso script.

Para garantirmos que foi executado correto vamos observar nossos arquivos de configuração, criados para cada roteador.


Configuração do Roteador 1	Configuração do Roteador 2
! hostname R1_floor1 ! no ip dhcp conflict logging ip dhcp excluded-address 1.1.1.9 1.1.1.10 ! ip dhcp pool POOL1 network 1.1.1.8 255.255.255.248 default-router 1.1.1.1 dns-server 8.8.8.8 8.8.4.4 ! interface loopback 10 description + Management + ip address 10.10.10.1 255.255.255.255 no shutdown !	! hostname R2_floor1 ! ! interface loopback 10 description + Management + ip address 10.10.10.1 255.255.255.255 no shutdown !

Vale lembrar, que não estou fazendo o acesso aos equipamento para descarregar as informações ( scripts ), pois não tenho todo esse inventário emulado nesse momento para inserir todos os roteadores. Caso tenha necessidade pode observar em nossos posts anteriores, mas a forma para implementar nos equipamentos seria adicionar essa task em nossa playbook ( ./script_jinja2/tasks/main.yaml ).

- name: Execute Script
  ios_config:
    provider: "{{ creds }}"
    src: ./template/configuration/script_{{ inventory_hostname }}.conf
  with_items: "{{ inventory_hostname }}"

Talvez vocês devem estar se perguntando onde está o ” loop ” da configuração. Exato, ele vai ser adicionado em nosso próximo post. 💡

Espero que vocês tenha gostado e deixem seus comentários.

Abs,
Rodrigo

Ansible – Configuração via CSV File – Parte 1

Thu, 08 Mar 2018 00:00:00 +0000

Olá Pessoal,

Dando sequência as nossas publicações sobre Ansible, e como já comentei com vocês que estou pegando alguns exemplos que de fato são situações que nós Engenheiros de Rede acaba vivenciado para executar esse tipo de trabalho em nosso dia a dia, ou seja, venho com a pergunta. Vocês já receberam aquele Excel ( .csv ), para de fato fazer algumas alterações em seus equipamentos?

Se sim, acredito que você está no caminho correto, pois hoje, venho com mais um exemplo que vamos fazer as preparações para tratar nossos dados e posteriormente criar nossos arquivos de configuração que serão aplicados em nossos equipamentos Cisco ( IOS ).

Vale lembrar, para que seja efetivo nossa Automação precisamos ter um inventário consolidado, onde as informações relacionadas ao nossos equipamentos devem ser coerentes para futuro crescimento de nossa infra-estrutura. Se você ainda não acompanhou os posts anteriores, recomenda-se ler esses tópicos sobre Ansible.

Como vocês podem observar vamos tratar nossos dados via um arquivo ( .csv ), que de alguma forma são valores/informações populadas através de outras fontes ( ferramentas, pessoas, etc ). Em nosso exemplo, estou colocando diversas informações que a principio vocês possam não entender, mas no decorrer de nossos posts isso fará sentido para o entendimento correto e as opções que podemos criar em nossa automação.

inventory_hostname,DHCP,dhcp_exclude1_start,dhcp_exclude1_end,dhcp_network,dhcp_netmask,dhcp_gateway,new_hostname,id_loopback,ip_loopback,mask_loopback
R1,true,1.1.1.9,1.1.1.10,1.1.1.8,255.255.255.248,1.1.1.1,R1_floor1,10,10.10.10.1,255.255.255.255
R2,false,1.1.1.9,1.1.1.10,1.1.1.8,255.255.255.248,1.1.1.1,R2_floor1,10,10.10.10.1,255.255.255.255
R3,false,1.1.1.9,1.1.1.10,1.1.1.8,255.255.255.248,1.1.1.1,R3_floor1,10,10.10.10.1,255.255.255.255
R4,false,1.1.1.9,1.1.1.10,1.1.1.8,255.255.255.248,1.1.1.1,R4_floor1,10,10.10.10.1,255.255.255.255
R31,true,1.1.1.9,1.1.1.10,1.1.1.8,255.255.255.248,1.1.1.1,R31_floor1,10,10.10.10.1,255.255.255.255
R32,true,1.1.1.9,1.1.1.10,1.1.1.8,255.255.255.248,1.1.1.1,R32_floor1,10,10.10.10.1,255.255.255.255
R5,false,1.1.1.9,1.1.1.10,1.1.1.8,255.255.255.248,1.1.1.1,R5_floor1,10,10.10.10.1,255.255.255.255
R6,true,1.1.1.9,1.1.1.10,1.1.1.8,255.255.255.248,1.1.1.1,R6_floor1,10,10.10.10.1,255.255.255.255

Como vocês podem observar isso são exemplos e vocês podem adaptar conforme sua necessidade e as solicitações que são exigidas pelas diferentes áreas de sua empresa. Todo o desenvolvimento de nossa automação também é muito co-relacionada com a estrutura de pastas e arquivos que vamos utilizar dentro do Ansible, portanto segue a estrutura que estou utilizando para esse exemplo.

Uma outra informação diferente dos exemplos citados em nossos posts sobre Ansible, é que estou criando como fictício todos esses roteadores em nosso arquivo de inventário ( ./hosts ), para que nosso exemplo seja mais robusto e obviamente no final de nosso exemplo irei demonstrar como aplicar as configurações. Segue meu inventário criado para esse exemplo:

[routers-client]
R1 ansible_host=192.168.0.22
R2 ansible_host=192.168.0.23
R31 ansible_host=192.168.0.24
R5 ansible_host=192.168.0.25
R6 ansible_host=192.168.0.26

Tendo como base essas informações vamos trabalhar com um módulo que Ansible oferece que é de executar um “ lookup ” dentro de um arquivo ( .csv ). Para que nosso código seja mais estruturado minha playbook principal irá chamar minha “ role ” definida como ( ./lookup_csv_info.yaml ).

---
- name: JINJA AND CSVFILE
  hosts: all
  gather_facts: no
  connection: local

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: LOOKUP IN CSV FILE
    include_role:
      name: lookup_csv_info
    when: ./excel/test.csv is defined

Talvez vocês devem estar se perguntando o porque utilizar “ roles ” dentro desse código? De fato a funcionalidade role é muito utilizada no sentido de trazer mais dinamismo, funcionalidade e flexibilidade para seu código, pois eles podem se tornar difíceis de gerenciar e difíceis de manter com um único arquivo. As roles permitem que você crie playbooks mínimas que, em seguida, busque uma estrutura de diretório para determinar as etapas de configurações reais que precisam executar, bem como proceder para as próximas roles se anterior foi executada/validada da forma correta.

Seguindo essa linha de raciocínio, demostro agora a playbook específica que irá pesquisar todas as informações dentro de nosso arquivo ( .csv ). Ressalto, que em nosso arquivo temos mais informações do que de fato existem ( hostnames ) nosso arquivo de ( ./hosts ), ou seja, estamos pesquisando em nossa planilha se existem elementos que coincidem com nosso inventário.

---
- name: GET VARIABLES FROM CSVFILE
  set_fact:
    vars_dict:
        DHCP: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=1 delimiter=,') }}"
        dhcp_exclude1_start: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=2 delimiter=,') }}"
        dhcp_exclude1_end: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=3 delimiter=,') }}"
        dhcp_network: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=4 delimiter=,') }}"
        dhcp_netmask: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=5 delimiter=,') }}"
        dhcp_gateway: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=6 delimiter=,') }}"
        new_hostname: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=7 delimiter=,') }}"
        id_loopback: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=8 delimiter=,') }}"
        ip_loopback: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=9 delimiter=,') }}"
        mask_loopback: "{{ lookup('csvfile', '{{ inventory_hostname }} file=./excel/test.csv col=10 delimiter=,') }}"
  with_items: "{{ inventory_hostname }}"

Para que possamos ver que as informações estão sendo capturadas vamos colocar uma task contendo debug de uma variável para observar o comportamento. Essa variável em nosso caso é ” var_dict ” onde se tem todo o ” dicionário ” com os valores populados de cada elemento. Para adicionar essa validação foi inserido o comando:

  - debug: var={{'vars_dict'}}

Desta forma temos esse output e a confirmação que os dados estão sendo populados corretamente.

Acredito que vocês observaram que temos todos os elementos que foram lidos/capturados baseado em cada coluna de nosso arquivo ( .csv ) comparado ao nosso inventário em uma única “ task “. Porquê?

Isso está relacionado justamente com ” loops ” que podemos criar dentro de nossas “ tasks “, fazendo com que ele faça a mesma tarefa diversas vezes baseado no requisito que estamos utilizando. Para nosso exemplo estou usando a variável “ {{ inventory_hostname }} “, justamente para que ela pesquise no arquivo todos os roteadores expostos no arquivo ( ./hosts ). Essa função pode ser observada através do ” with_items: “.

Espero que vocês tenham gostado e no próximo post vou detalhar como trabalhar com esse dados.

Abs,
Rodrigo

Ansible – Instalar SSH usando processo de automação

Thu, 21 Dec 2017 00:00:00 +0000

Olá Pessoal,

Já faz um bom tempo que não escrevo aqui no BLOG, mas tudo isso é devido outras tarefas que estão tomando também um certo tempo ( recertificação CCIE, estudos DevOps, projetos particulares, aulas, treinamentos, etc ). Enfim, hoje venho aqui trazer uma situação real que acredito que diversos leitores de nosso canal podem vivenciar em sua infra-estrutura e de alguma forma já fizeram esse questionamento quando começei aqui explicar sobre Ansible 💡 . Você pode conferir nossos posts sobre Ansible aqui.

De fato, vocês observaram que a todo momento o que implementamos usando essa ferramenta foi utilizando o processo de acesso remoto a nossos equipamentos, é claro, executando as operações necessarias via CLI. Mas qual é esse acesso remoto? **SSH.

Pois bem, se observarmos todos os módulos para Networking os acessos aos equipamentos é feito pela biblioteca ” Paramiko “, e antes da versão 2.4 do Ansible não tinhamos nenhum módulo para utilizarmos os acessos via Telnet. Devido a isso, foi criado na versão 2.4.0 um módulo para que pudessemos avaliar os equipamentos ou executar algum comando ( CLI ) pelo acesso via Telnet. Esse módulo você pode conferir através desse link ( Telnet no Ansible ).

Baseado nesses fatos, a ideia é acessar os equipamento via telnet, implementar script para habilitar o SSH, e após essa configuração toda a nossa infra-estrutura já estaria apta para utilizar-se de uma metodologia de maior segurança para acesso remoto aos equipamentos e pronto para trabalharmos com qualquer outro módulo disponível dentro da estrutura do Ansible. O que posso dizer é, mais ou menos!!!

Como estamos pensando em automação vamos pontuar os ítens para que isso seja efetivo:

Acessar o equipamento via telnet.
Verificar se o equipamento tem o ssh habilitado.
Qual a versão implementada do SSH.
Caso negativo, devemos instalar o script para acesso via SSH e importar a chave SSH para o host remoto da gerência para evitarmos as perguntas se queremos aceitar a chave em nosso primeiro acesso.
Caso positivo, devemos importar a chave SSH para o host remoto da gerência para evitarmos as perguntas se queremos aceitar a chave em nosso primeiro acesso.

As dificuldades encontradas com o módulo telnet do Ansible é de fato capturar alguns logs ( utilizar pipe ) e fazer as tratativas dos outputs para obter somente o necessário, então o desafio foi encontrar biblioteca para usarmos nesta demanda. Depois de avaliar diferentes caminhos/testes e pedir ajuda à grupo discussão no SLACK Networktocode ( onde indico para todos com intuito adquirir experiências com essas pessoas, e claro, de uma comunidade que de fato ajuda muito nas dúvidas e idéias para desenvolvermos nossas soluções ), verifiquei poderíamos trabalhar com a biblioteca ” ntc-ansible “, pois ela já oferece o acesso via telnet e temos diversos outputs ” show commands ” formatados JSON ” JavaScript Object Notation “, onde a comunidade executou via TextFSM, trazendo assim esse ” array ” para ficar de fato mais pratico a consulta de nossos outputs. Mas, nossa vida não é fácil, pois esse comando que é necessario em minha playbook não tinhamos pronto, porém não foi impactante devido a conseguir executar os filtros e capturar o output essencial do comando.

Para nossa estrutura de arquivos e pastas eu desenvolvi desta forma.

Vocês podem observar que temos uma estrutura de ” roles “, ” templates ” e ” output ” onde a principal pasta para corresponder a nossa playbook estaria dentro de roles, desta forma podemos fazer nossas validações ” conditionals ” na playbook e trabalhar baseado nos outputs/status para as execuções das tarefas posteriores. Nosso arquivo raiz para iniciar implementação estaria em ” ssh_config.yaml “.

---
- name: INSTALL SSH IN CISCO DEVICES
  hosts: routers-client
  gather_facts: no
  connection: local
  vars:
    template_dir: /home/rodrigo/Documents/ansible/ntc-ansible/ntc-templates/templates/

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: INCLUDE SSH ENABLE ROLE
    include_role:
      name: ensure_ssh_enabled

  - name: INCLUDE SSH KEY ON THE PATH .ssh/known_hosts
    include_role:
      name: get_ssh_key

Como podem observar a primeira validação é garantir se temos implementado o SSH, e caso negativo, iremos fazer a implementação de nosso script. Dentro da estrutura de roles podemos ter diversos arquivos denominados com o mesmo nome, porém ele sempre irá buscar o arquivo main.yaml que é a base de nossa role.

---
- name: ACCESS BY TELNET
  ntc_show_command:
      connection: telnet
      platform: cisco_ios
      template_dir: "{{ template_dir }}"
      command: "{{ item }}"
      host: "{{ inventory_hostname }}"
      username: "{{ creds['username'] }}"
      password: "{{ creds['password'] }}"
      secret: "{{ creds['auth_pass'] }}"
  with_items:
      - show ip ssh | include SSH Enabled - version 2
  register: ssh_telnet

- name: ENABLE SSH IF REQUIRED
  include_tasks: enable_ssh.yaml
  when: "ssh_telnet.results.0.response.0 != 'SSH Enabled - version 2.0'"

Para ficar mais claro vocês podem observar no debug ( via ah-hoc command ” -vvv ” ) output sendo demostrado com valor essencial para validar via condição ( when ) de qualquer coisa que seja diferente de versão 2 , então ele irá chamar nossa próxima task para implementar nosso script.

PS.: Nessa execução o valor é o mesmo comparado portando ele esta executando o ” skipping “

Em nossa próxima task temos novamente o acesso sendo executado via telnet e a implementação dos comandos necessário para subirmos o protocolo SSH, liberando assim esse equipamento para seus devidos fins.

---
- name: INSTALL SSH TEMPLATE
  ntc_config_command:
      connection: telnet
      platform: cisco_ios
      host: "{{ inventory_hostname }}"
      username: "{{ creds['username'] }}"
      password: "{{ creds['password'] }}"
      secret: "{{ creds['auth_pass'] }}"
      commands_file: "/home/rodrigo/Documents/ansible/IWAN Project/ssh_installation_by_telnet/template/ssh_configuration.txt"

Após toda essa validação e configuração ( se necessario ) nós precisamos fazer com que nosso host tenha essa chave inserida em seu arquivo de controle ( ~/.ssh/known_hosts ) para que ele não faça essa pergunta chata quando for acessar pela primeira vez seu equipamento.

Para isso, iremos ter nossa próxima role para trazer essas validações e inserções dentro do arquivo necessário. Após chamar role ” get_ssh_key ” iremos novamente ter nosso arquivo main.yaml sendo executado e nele iremos tratar as informações.

---
- name: ACCESS BY TELNET
  ntc_show_command:
      connection: telnet
      platform: cisco_ios
      template_dir: "{{ template_dir }}"
      command: "{{ item }}"
      host: "{{ inventory_hostname }}"
      username: "{{ creds['username'] }}"
      password: "{{ creds['password'] }}"
      secret: "{{ creds['auth_pass'] }}"
  with_items:
      - show ip ssh | begin ^ssh-rsa
  register: ssh_key

- name: Save output in variable related inline command
  set_fact: myvar="{{ ssh_key.results.0.response.0 }}"
  when: ssh_key is defined

- name: Replace space inside myvar
  set_fact:
    clean: "{{ myvar.replace('\n','') }}"
  when: ssh_key is defined

- name: ADD KEY INSIDE LOCALHOST OF SSH CONNECTION
  lineinfile:
    path: ~/.ssh/fake_hosts
    state: present
    line: "{{ inventory_hostname }} {{ clean }}"
    insertafter: EOF
  when: ssh_key is defined

Um dos problemas enfrentados nesse tópico foi justamente a comparação da chave existente com o fato de possívelmente eu já ter essa chave inserida em seu arquivo de hosts, portanto dependendo de sua infra-estrutura essas informações poderiam ficar duplicadas e também a cada execução ele salvar a mesma chave em seu arquivo. Para validação no arquivo temos um módulo muito interessante chamado ” lineinfile ” que de fato ele pesquisa no arquivo se temos essa informação, caso negativo, ele insere o que foi solicitado. Como dito o problema sobre a inserção toda vez que executava a playbook ficava atrelado algum espaço ( \n ) que ele tinha do output ficando interpretável para o modulo lineinfile, com isso precisou ser feito um ” replace ” desses espaços para que pudesse comparar minha variável com o arquivo.

PS.: Vocês vão observar que criei um arquivo ” fake_hosts ” justamente para que você não fique testando dentro de seu arquivo de produção e de alguma forma possa impactar aquilo que esta funcionado, portanto criei o arquivo para você validar os seus passos e analisar se esta sendo executado da maneira correta, pois no momento de rodar talvez em cima de 100, 300 devices o rollback pode ficar complicado. ( rsrs )

Vamos partir do principio que não temos nada instalado em nosso equipamento e a configuração que será implementado é conforme abaixo.

!
username ssh privilege 15 password 0 sshansible
!
ip domain-name cisco.com
!
crypto key generate rsa modulus 2048
!
ip ssh version 2
ip ssh source-interface g3
ip ssh time-out 5
!
line vty 0 4
 login local
 transport input all
!

Abaixo você pode conferir que removi toda a configuração de ssh e deletei no meu arquivo de teste para garantir que não temos nada populado.

Com isso, em nosso próximo output você poderá observar que de fato não consigo fazer nenhum acesso SSH, e após execução de nossa playbook ( capturando duas changes ) temos de fato implementado nosso script e chave inserida. O erro mencionado abaixo em meu detalhamento refere-se ao fato de eu não ter salvo nossa chave SSH no arquivo correto, devido ao que foi comentando logo acima.

Para garantir podemos acessar nosso equipamento e consolidar as informações relacionados ao script implementado, bem como, adicionei um novo usuario.

Validando nosso arquivo ” fake_hosts ” para garantir que temos a mesma chave inserida no arquivo e comparado ao nosso equipamento.\

Vale lembrar que, o foi adicionado em nosso arquivo de ” known_hosts ” é o hostname, portanto se você acessa seus equipamentos pelo nome ele terá essa menção adicionado no arquivo, porém se o DNS não resolver esse nome você terá que acessar pelo endereço IP e que nesse caso não é a mesma informação que populamos em nosso arquivo de “ known_hosts “, sendo assim ele irá questionar para adicionar sua chave.

Logo abaixo, coloco alguns exemplo para garantir o correto funcionamento, colocando hipóteses de alguns itens que podemos obter durante a implementação que diversos hosts.

Nesse caso foi removido apenas ” no ip ssh version 2 ” para que possamos implementar o script, mas não inserir chaves duplicadas em nosso arquivo.

Declaro que esse post ficou bem grande, porém quis demonstrar todas as possibilidades colocando os outputs e anuências que foram vivenciadas até o desenvolvimento dessa automação.

Espero que vocês tenham gostado e de fato ajude de alguma forma a solucionar problemas vivenciados em seu dia a dia. Fique a vontade de compartilhar esse artigo e de colocar mais sugestões ou melhorias para essa estrutura.

Esses códigos estão disponivéis também no meu Github. 😛

Abs,
Rodrigo

Ansible – Módulo Networking

Fri, 24 Nov 2017 00:00:00 +0000

Olá Pessoal,

Acredito que vocês vêem acompanhando sobre os posts que estou descrevendo sobre essa nova tecnologia de ” DevOps ” para qual estou me atualizando baseado em Ansible.

Devido a isso gostaria de divulgar algumas informações adicionais para vocês que também estão se interessando nesse tópico, trazendo assim um histórico para nosso BLOG sobre essa comunidade que está crescendo e principalmente os módulos de networking está tendo uma visbilidade muito importante não somente da RedHat, mas em relação também as vendors de oferecerem essas facilidades para comunidade.

Com isso, gostaria de agregar aquilo que já comentei em nosso 3 post sobre o módulo de networking, bem como agora podemos acompanhar evolução ( roadmap ) das novas versão que estão para chegar. Aqui são slides que capturei para apresentar para vocês, porém se desejam ver na integra temos o Ansible Webinar Networking.

Abs,
Rodrigo

Ansible – Validação de Configuração – Parte 3

Mon, 30 Oct 2017 00:00:00 +0000

Olá Pessoal,

Seguindo em nossos posts, continuamos trabalhando para fazer nossas comparações entre as configurações que estão aplicadas em nosso ambiente. Hoje vamos tratar sobre a validação do módulo ” startup-config “.

Como vocês observaram anteriormente, sempre estavamos validando situações onde iríamos comparar arquivos ( scripts ) que poderiam ser aplicados em nossos equipamentos ou validados no sentido de possíveis alterações que de fato não se equipara com nossa base ( backup ).

Logo abaixo, iremos fazer uma validação simples entre “ startup-config ” com a ” running-config “, com isso temos outro motivo para possíveis troubleshooting identificar rapidamente se algo foi alterado, e se de fato essa alteração foi feita da maneira correta, sempre lembrando-se que, essas alterações podem aparecer desde que ainda não foram salvas na NVRAM. Abaixo temos o script:

---
- hosts: all
  connection: local
  gather_facts: no

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: Fill vars
    set_fact:
      provider:
        host: "{{ ansible_host }}"
        username: "{{ creds['username'] }}"
        password: "{{ creds['password'] }}"
        auth_pass: "{{ creds['auth_pass'] }}"

  - name: Compare startup-config with running-config
    ios_config:
      diff_against: startup
      provider: "{{ provider }}"
    register: test_diff

  - name: Take startup-config and sets it to a variable called *before*
    set_fact: before="{{ test_diff['diff']['before'].split('\n')}}"
    when: test_diff['diff'] is defined

  - name: This takes the running_config and sets it to a variable called *after*
    set_fact: after="{{ test_diff['diff']['after'].split('\n')}}"
    when: test_diff['diff'] is defined

  - name: Create a line-to-line diff of running-config to startup_config
    set_fact: difference="{{ after | difference(before) }}"
    when: test_diff['diff'] is defined

  - name: sanitized output "Lines added to running-config that are not present in startup_config"
    debug:
      var: difference
    when: test_diff['diff'] is defined

Vale ressaltar que utilizamos a mesma técnica já explicada anteriormente, onde temos que “ sanitizar ” as diferenças para que de fato tenhamos a saída mais ” clean ” possível, e claro de fácil visualização. No primeiro momento, como vocês vão perceber apenas executei nossa playbook para demonstrar que de fato meu equipamento foi ligado e permanece com a mesma configuração.

A mensangem ” skipping ” é justamente para mencionar que nossa variável esta ” zerada ” e que essa tarefa está sendo pulada para as tarefas seguintes. Segue abaixo:

Agora, como já temos tudo garantido, vamos novamente fazer uma alteração em nosso roteador relacionado a um novo usuário, e claro, não vamos salvar em nossa NVRAM.

Feito isso, agora esperamos que após execução da playbook iremos visualizar que nosso novo usuário foi inserido na ” running-config “. Segue abaixo o output trazendo assim a linha adicional:

Com isso, finalizamos nossas 3 opções de validação de configuração, para qual pode atender diversas opções dentro de nosso ambiente de produção ou mesmo de futuros laboratórios. Pensando assim, vendo nossas demonstrações você avalia que isso de fato pode automatizar algum processo que hoje você precisa executar manualmente ou não consiga gerenciar suas configurações de equipamentos? O que seria mais interessante?

PS.: Vale lembrar novamente que estamos executando somente em um roteador, porém isso, pode ser escalável a muitos equipamentos, apenas alterando nosso arquivo de hosts.

Deixe seus comentários.

Abs,
Rodrigo

Ansible – Validação de Configuração – Parte 2

Thu, 26 Oct 2017 00:00:00 +0000

Olá Pessoal,

Conforme em nosso post anterior, hoje iremos tratar de um outro parâmetro, com o intuito de fazer validação das configurações em nossos equipamentos Cisco.

Baseando-se em nossas menções a configuração que iremos “confrontar” será a diferença que temos na “running-config” com nosso arquivo base ( intended ), ou seja, nesse post iremos agora mostrar o que temos de comandos adicionais na configuração que não esta presente em nosso arquivo padrão.

Vale lembrar que essa comparação será linha à linha, ou seja, para que isso faça mais sentido o ideal que você já tenha um template padrão de sua infra-estrutura aplicado para seus equipamentos, bem como, já tenha um histórico de armazenamento de configurações para começar a “confrontar” as configuração. É claro, que se você não tem, o importante é iniciar seu processo para backup de configuração ou criar políticas para que esse processo entre em produção, assim posteriomente, você pode revalidar suas configurações com o desejo de encontrar algo que foi alterado e que não deveria. 😉

Enfim, vamos ao nosso playbook onde iremos criar a validação. Devido ao teste eu acabei criando um processo anterior nesse script, baseando-se em configurações já apresentadas em posts anteriores sobre criação do “running-config“, devido a isso, eu apenas importei esse script para nosso playbook com a intenção de conseguir criar o arquivo inicial, e após isso, criar duas situações para comparar o antes e depois da mudança em nossa configuração do roteadore CSR1000V.

Segue abaixo nossa playbook

---
- hosts: all
  connection: local
  gather_facts: no

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: Fill vars
    set_fact:
      provider:
        host: "{{ ansible_host }}"
        username: "{{ creds['username'] }}"
        password: "{{ creds['password'] }}"
        auth_pass: "{{ creds['auth_pass'] }}"

  - name: Capture running-config
    ios_command:
     provider: "{{ provider }}"
     commands:
        - show running-config
    register: running
    
  - name: Check that file exist
    stat:
      path: /home/rodrigo/Documents/ansible/IWAN Project/backup/{{ inventory_hostname }}_running.txt
    register: result_file

  - name: Save output running-config
    copy:
      content: "{{ running.stdout[0] }}"
      dest: "/home/rodrigo/Documents/ansible/IWAN Project/backup/{{ inventory_hostname }}_running.txt"
    when: result_file.stat.exists == False

  - name: Compare running-config with intended file
    ios_config:
      diff_against: intended
      provider: "{{ provider }}"
      intended_config: "{{ lookup('file', '/home/rodrigo/Documents/ansible/IWAN Project/backup/{{ inventory_hostname }}_running.txt') }}"
    register: test_diff

  - name: Take running-config and sets it to a variable called *before*
    set_fact: before="{{ test_diff['diff']['before'].split('\n')}}"
    when: test_diff['diff'] is defined

  - name: This takes the intended_config and sets it to a variable called *after*
    set_fact: after="{{ test_diff['diff']['after'].split('\n')}}"
    when: test_diff['diff'] is defined

  - name: Create a line-to-line diff of running-config to intended_config
    set_fact: difference="{{ after | difference(before) }}"
    when: test_diff['diff'] is defined

  - name: sanitized output "Lines added to running-config that are not present in intended_config"
    debug:
      var: difference
    when: test_diff['diff'] is defined

No primeiro momento vocês podem observar que minha pasta não contém o arquivo, pois é a primeira vez que irei executar minha playbook. Após executar, vocês podem observar que tenho a mensagem de “ change ” em nosso “ log ” e consequentemente vamos observar que foi populado um novo arquivo em nosso servidor local ( ansible server ). \

Após criação de nosso arquivo, nesse momento é efetuado alteração em meu roteador ( running-config ) criando um usuário adicional, para que assim possamos validar as diferenças de configurações que existem entre nossas bases. Segue abaixo:

Com isso vocês agora podem observar que foi criado uma lógica de validação em relação ao meu arquivo de configuração ( running-config ), para que após a execução pela primeira vez da running-config ele não fique sobrescrevendo meu arquivo, para que desta forma, ela seja, minha configuração base ( intended ) que vou comparar posteriormente com o running-config. Abaixo você pode observar que existe uma ação ( skipping ) que é o momento de validação do arquivo existente, sendo que minha váriavel agora é ” True ” devido a isso minha tarefa em nossa playbook, não sera de fato executada ( gravar um novo arquivo ).

Podemos também observar outras ações que estão ocorrendo que é justamente as menções de diferenças entre os arquivos, que é demonstrador através do ” before ” e “ after “. Para que vocês possam entender o que representa output em azul trazendo numeros é simbolo é recomendado que visualize esse link.

Após todo essa validação o ideal que você faça as comparações do antes e depois de forma mais prática para seu output, pois, você pode obter linhas que de fato são adicionais em seu output, mas que de fato não foram alteradas. Devido a isso, foi necessário criar uma revalidação e ” sanitizar ” output utilizando as variáveis “ before ” e ” after ” para que possamos no final visualizar somente a linha que eu adicionei no running-config. Com esse output podemos concluir que de fato agora tenho uma alteração em meu equipamento que não deveria estar contido nele.

Espero que esse playbook possa dar um dinamismo maior para sua infra, na qual você precisa validar se algo foi alterado ( change ) em seu equipamento e que de fato posso ter impactado algum incidente reportado posteriomente sua change. Vale lembra que aqui estamos fazendo os testes em apenas 1 equipamento para qual a ideia é que isso possa ser escalonado dentro de seu ambiente. 😀

Abs,
Rodrigo

Ansible – Validação de Configurações

Mon, 23 Oct 2017 00:00:00 +0000

Olá Pessoal,

Enfim, depois de um longo periodo voltamos para trazer mais tópicos sobre nossa estrutura de DevOps utilizando Ansible. Acredito que algumas pessoas devem ter visto que a RedHat fez anúncio sobre atualização do Ansible para a versão 2.4, e se observarem o módulo de networking foi o que teve a maior quantidade de release, portanto podemos observar que o projeto e a comunidade esta empenhanda em trazer mais beneficios para nossa área. Segue a menção explicada pelo engenheiro do modulo de networking da RedHat

Para critério de equiparação eu já fiz atualização para a nova versão, pois nossos exemplos e laboratórios já estão com os novos módulos. Segue a versão que estamos trabalhando nesse momento.

root@ubuntu:/home/rodrigo# ansible –version ansible 2.4.0.0 config file = /etc/ansible/ansible.cfg configured module search path = [u’/root/.ansible/plugins/modules’, u’/usr/share/ansible/plugins/modules’] ansible python module location = /usr/lib/python2.7/dist-packages/ansible executable location = /usr/bin/ansible python version = 2.7.12 (default, Nov 19 2016, 06:48:10) [GCC 5.4.0 20160609]

Como estamos trabalhando em exemplos sobre backups de configuração, historico de configuração, neste post vou trazer algumas funcionalidades que temos agora para comparar nossas configurações e obter outputs que podem trazer beneficios em nosso dia a dia. O módulo voltado para Cisco, onde iremos trabalhar seria “ ios_config “, que por sua vez, teve algumas alterações nessa nova edição. Para contextualizar, existem algumas possibilidades que dependendo do seu ambiente podem-se enquadrar de uma forma diferente, portanto, para nosso caso eu irei criar um arquivo ( .conf ) que iremos apenas adicionar usuários para que possamos comparar nossas configurações. Segue exemplo de meu arquivo:

!
username R1 privilege 15 password 0 rodrigo3
username teste2 privilege 15 password 0 rodrigo3
username teste12 privilege 15 password 0 teste
!
!

PS.: Não é obrigatório a criação do arquivo como sendo ( .conf ), ele pode ser como texto e utilizar a estrutura que você tem em seu ambiente.

Após a criação de nosso arquivo base, iremos construir nosso playbook para que possamos fazer as comparações das configurações. Neste primeiro exemplo, iremos fazer a comparação da ” running-config ” com o arquivo base, e assim output que irá trazer em nossa variavél será a diferença entre os dois arquivos.

---
- hosts: all
  connection: local
  gather_facts: no

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: Fill vars
    set_fact:
      provider:
        host: "{{ ansible_host }}"
        username: "{{ creds['username'] }}"
        password: "{{ creds['password'] }}"
        auth_pass: "{{ creds['auth_pass'] }}"

  - name: Compare running-config with base file
    ios_config:
      diff_against: running
      provider: "{{ provider }}"
      src: /home/rodrigo/Documents/ansible/input/{{ inventory_hostname }}.conf
    register: test_diff

  - debug: var=test_diff.updates

Com isso, podemos agora fazer nossa validação através de nosso playbook utilizando comando ad-hoc ( –check ). Vale lembrar que o “check” não irá popular nenhuma configuração em seu equipamento.

Assim podemos comparar com nossa configuração apresentada em nosso roteador que os usuários não estão presentes em nossa configuração ( running-config ), entretanto vocês podem observar que temos um usuario ( rodrigo ) que o mesmo não foi demostrado em nosso output. Porque?

Isso ocorre porque a validação que é feita é somente a comparação do R1.conf com a running-config, trazendo assim somentes as diferenças ( check ) do que temos na configuração base com o que está no roteador ( running-config ), e não o inverso. Teremos outras funções para que essa diferença também seja apresentada.

Devido a este ponto, para os próximos posts irei trazer mais validações usando essa nova funcionalidade ( diff_against ).

Abs,
Rodrigo

Cisco DevNet Webinar – Netacad – Sessão 2

Wed, 06 Sep 2017 00:00:00 +0000

Olá Pessoal,

Eu já havia comentado sobre esse tópico em nosso post de Julho, e hoje venho para avisar sobre a próxima sessão que será feita neste mês ( 14/09/2017 ). Não sei se todos assistiram Webinar anterior, mas nesse evento será comentado sobre mais alguns ítens sobre o entendimento de conceitos básicos de software e código e vantagens que engenheiro de redes pode ganhar colaborando with desenvolvimento de software. Irá ser feito uma pequena demo mostrando codificação Python e JSON

Você pode conferir com mais detalhes através do link do NETACAD.

Abs,
Rodrigo

Ansible – Notificação BOT Telegram

Mon, 04 Sep 2017 00:00:00 +0000

Olá Pessoal,

Seguindo nossa sequência sobre Ansible, hoje gostaria de trazer um adendo que estaria envolvido simplesmente em criar uma notificação que poderá ser exibida no Telegram, através de nossos famosos e tão comentado BOTs.

Para que todo esse processo funcione, você terá a necessidade de criar um BOT simples pelo Telegram, para isso você pode interagir com nosso amigo @BotFather. Se necessitar de mais informações sobre os procedimentos para criação desse BOT, recomendo que pesquise nesse link, na pagina do Telegram.

Em nossos testes eu criei meu BOT e vou utiliza-lo para fazer as notificações para uma sala de teste, no intuito de inserir meu BOT para visualizar as notificações.

Seguindo com nossas configurações, irei utilizar o mesmo exemplo que já estamos trabalhando, porém vou agregar mais um arquivo no projeto, denominado como telegram.yaml

---
  - name: Send test message
    telegram:
        token: bot000:xxxx
        chat_id: -yyyy
        msg: Ansible playbook executed

Como podem observar eu omiti algumas informações de nosso exemplo devido a ser referenciado ao meu token e ID de BOT, portanto a partir de seu BOT essas informações vocês devem alterar olhando especificamente em seu BOT.

Um dos motivos mais difíceis para conseguir funcionar essa notificação através do BOT, foi conseguir adquirir esse chat_id, que com exclusividade vou detalhar um pouco de que forma facilitar sua vida.

Como exemplo o nome do BOT seria rodrigo_bot

Você deve inserir seu BOT em um grupo
Você precisa enviar uma mensagem em seu grupo para seu BOT
1. Neste caso você deve fazer /my_id @rodrigo_bot ( Eu tentei diversas mensagens, mas a única que trouxe a informação foi utilizando /my_id )
Em seu browser você deve colocarhttps://api.telegram.org/botXXX:YYYY/getUpdates ( lembre-se de trocar as variáveis citadas pelo token de seu BOT )
Após a resposta você deve procurar pelo campo ,“chat”:{“id”:-xxxxxx
BINGO!!!! 😆

Enfim, agora você pode utilizar as informações para preencher em seu arquivo do Ansible ( telegram.yaml ). Se quiser fazer um teste antes para validar sobre o chat-id o telegram aceita notificação via CURL. Esse comando é aceito no Linux ( curl -X POST “https://api.telegram.org/botxxx:yyyyy/sendMessage” -d “chat_id=-wwwww&text=my sample text” ), lembrando-se que para funcionar você precisa anexar suas informações de token e chat_id.

Para que possamos finalizar eu chamei através de nosso arquivo principal ( backup_router.yaml ) nossa notificação na sala de bate papo.

---
- name: Configuration Backup in Cisco Devices
  hosts: routers
  gather_facts: no
  connection: local

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: Define access
    set_fact:
      provider:
        host: "{{ ansible_host }}"
        username: "{{ creds['username'] }}"
        password: "{{ creds['password'] }}"
        auth_pass: "{{ creds['auth_pass'] }}"

  - name: Obtain commands
    include: commands_variance.yaml

  - name: Obtain Telegram
    include: telegram.yaml

Segue a execução de nossa playbook. Nesse caso chamei duas mensagens para popular mais opções para você.

Após a execução podemos consultar em nossa sala de bate papo nossa mensagem populada.

Espero que tenham gostado e nossa próxima integração será através de outra ferramenta de messaging. Aguardem!!!

Abs,
Rodrigo

Ansible – Variações no Playbook – ” Include “

Mon, 14 Aug 2017 00:00:00 +0000

Olá Pessoal,

Baseando-se em nosso ultimo post, acredito que vocês tenham pensado em algumas alternativas para capturar comandos dos equipamentos ou de alguma forma ser mais flexível para armazenar arquivos. Pensando em algumas alternativas segue aquelas que acho interessante compartilhar com vocês para que isso possa de alguma forma ser uma implementação dentro de seu ambiente.

Como vocês observaram nosso arquivo de texto estava sendo salvo com o IP do equipamento, talvez isso não seja interessante e você gostaria de salvar esse documento através do hostname do equipamento, tendo isso como principio vamos fazer algumas alterações para que isso possa acontecer. Nosso primeiro passo é editar o arquivo de hosts ( inventário ) colocando nele a denominação do hostname e nossa variável ” ansible_host ” obviamente atrelado ao nosso IP de gerenciamento.

[routers]
R1 ansible_host=192.168.0.19

Desta forma precisamos fazer uma pequena alteração em nosso playbook adicionando a variável ” inventory_hostname ” no momento de salvar nosso arquivo ( .txt ). Para ficar melhor documentado, vocês podem observar que podemos adicionar algo após nossa variável, e assim a documentação do nome desse arquivo fica personalizada. 🙂

Segue abaixo nosso novo arquivo:

---
- name: Acesso remoto aos equipamentos
  hosts: routers
  gather_facts: no
  connection: local

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: Define access
    set_fact:
      provider:
        host: "{{ ansible_host }}"
        username: "{{ creds['username'] }}"
        password: "{{ creds['password'] }}"
        auth_pass: "{{ creds['auth_pass'] }}"

  - name: show running-config
    ios_command:
     provider: "{{ provider }}"
     commands:
        - show running-config
    register: config

  - name: save output Running
    copy:
      content: "{{ config.stdout[0] }}"
      dest: "/home/rodrigo/Documents/ansible/{{ inventory_hostname }}_running.txt"

Com isso, podemos executar nosso playbook como explicado anteriormente, e logo vocês podem observar a diferença de ” output “, para qual temos o hostname populado ” R1 “, bem como o arquivo de texto que foi gerado como ” R1_running.txt “

Depois de fazermos essas alterações vocês talvez queiram incluir mais comandos em nossa playbook, para que de alguma forma seja documentado, ou seja, vocês podem ir adicionando mais comandos conforme exemplo anterior e salvar em um novo arquivo. Segue exemplo para adicionarmos mais comandos:

- name: show version
    ios_command:
      provider: "{{ provider }}"
      commands:
        - show version
    register: config

  - name: save output Version
    copy:
      content: "{{ config.stdout[0] }}"
      dest: "/home/rodrigo/Documents/ansible/{{ inventory_hostname }}_version.txt"

Após compilar novamente nossa playbook vocês podem observar que foram executados os dois comandos e consequentemente gerados dois arquivos.

Agora vêm o ponto, pensando em comandos e sobre a escalabilidade desse formato, onde teremos uma playbook gigantesca para executar várias tarefas. 💡 O que podemos fazer?

Acredito que seja mais interessante criarmos um arquivo ( yaml ), onde colocaremos todos nossos comandos, e desta forma, podemos chamar esse arquivo através de nossa playbook principal, assim ela não fica poluída com varias ações para ser executada. Para isso devemos usar nosso modulo “ include “, conforme segue abaixo em nosso script.

---
- name: Acesso remoto aos equipamentos
  hosts: routers
  gather_facts: no
  connection: local

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: Define access
    set_fact:
      provider:
        host: "{{ ansible_host }}"
        username: "{{ creds['username'] }}"
        password: "{{ creds['password'] }}"
        auth_pass: "{{ creds['auth_pass'] }}"

  - name: Obtain commands
    include: commands_variance.yaml

Após essa inserção eu criei um novo documento ( yaml ), onde foi inserido todos os comandos que desejo fazer para meu equipamento, e assim fica mais claro as execuções de tarefas dentro de nossa playbook.

---
  - name: show running-config
    ios_command:
     provider: "{{ provider }}"
     commands:
        - show running-config
    register: config

  - name: save output Running
    copy:
      content: "{{ config.stdout[0] }}"
      dest: "/home/rodrigo/Documents/ansible/{{ inventory_hostname }}_running.txt"

  - name: show version
    ios_command:
      provider: "{{ provider }}"
      commands:
        - show version
    register: config

  - name: save output Version
    copy:
      content: "{{ config.stdout[0] }}"
      dest: "/home/rodrigo/Documents/ansible/{{ inventory_hostname }}_version.txt"

Após a execução o mesmo output é observado, porém temos uma estruturação muito mais adequada para execução e mapeamento de seu script. O que acharam? Deixem seus comentários.

Abs,
Rodrigo

Ansible – Criação do Playbook

Wed, 09 Aug 2017 00:00:00 +0000

Olá Pessoal,

Conforme mencionado em nosso último post, hoje gostaria de trazer para você as configurações executadas em nosso playbook, para que possamos acessar nosso equipamento Cisco ( CSR1000V ) para capturar sua configuração ( running-config ) e salvar essa configuração em uma pasta específica. Para que isso possa acontecer é necessário fazer algumas validações, e assim garantir acesso ao nosso equipamento. Primeiramente um teste rápido que devemos executar via Ubuntu é fazermos o teste de ping, conforme abaixo:

Após esse processo devemos garantir que nosso roteador é acessível via protocolo SSH ( Secure Shell ), isso é necessário porque o Ansible utiliza-se somente desse protocolo para acesso aos equipamentos ( Roteadores, Switches, Servidores, etc ) e quando pensarmos nessa utilização precisamos garantir que o protocolo SSH esteja habilitado em nosso equipamento e da mesma forma acessível. Conforme abaixo, eu estou executando o acesso ao meu equipamento, e como esperado ele me questiona para confirmação de acesso usando uma nova chave de SSH para o equipamento. Após esse processo digito a senha e tenho acesso completo ao equipamento. Se tiver interesse em habilitar o SSH Server no Ubuntu siga esse procedimento, mas nesse momento você não precisa se preocupar em habilitar esse serviço nesse sistema operacional.

Após esse acesso podemos validar em nosso roteador qual sessão foi estabelecida com o equipamento, bem como verificar o tipo de criptografia, status e username logado. Conforme mostrado na figura com a representação numero ( 1 ).

Logo abaixo, temos maiores detalhes sobre a conexão e a chave criptográfica utilizada pelo protocolo. Após essa validação, eu saio do modo de acesso via SSH ao roteador e podemos observar na figura com a representação numero ( 2 ) que não temos mais nenhuma sessão estabelecida com o equipamento. Se quiser monitorar acesso ao seu roteador habilite o ” debug ip ssh detail “.

Para que vocês possam fazer a configuração de SSH ao nosso roteador segue os comandos básicos abaixo, vale lembra que aqui nesse ambiente de teste estou utilizando um usuário local criado no equipamento com acesso privilegiado, entretanto devemos lembrar que ambientes mais robustos seria interessante que esse usuario fosse autenticado através de outras plataformas como Radius, TACACS+.

!
username rodrigo privilege 15 password 0 rodrigo
!
ip domain name cisco.com
!
ip ssh time-out 60
ip ssh source-interface GigabitEthernet3
ip ssh version 2
!
line vty 0 15
login local
transport input ssh

Enfim, depois de garantir total acesso ao equipamento, segue abaixo a configuração de nosso playbook para que possamos capturar o ” show running-config “.

---
- hosts: routers
  gather_facts: no
  connection: local

  tasks:
  - name: OBTAIN LOGIN CREDENTIALS
    include_vars: secret.yaml

  - name: Define access
    set_fact:
      provider:
        host: "{{ ansible_host }}"
        username: "{{ creds['username'] }}"
        password: "{{ creds['password'] }}"
        auth_pass: "{{ creds['auth_pass'] }}"

  - name: show running-config
    ios_command:
     provider: "{{ provider }}"
     commands:
        - show run
    register: config

  - name: save output to /home/rodrigo/Documents/ansible
    copy:
      content: "{{ config.stdout[0] }}"
      dest: "/home/rodrigo/Documents/ansible/{{ ansible_host }}.txt"

Podemos observar abaixo que temos nossos arquivos criados, conforme em nossos posts anteriores e devidamente validado, pois no presente momento não temos nenhum backup de configuração ( .txt )

Após todo esse processo devemos executar nosso playbook através do comando ” ansible-playbook -i hosts backup_cisco_router.yaml “. Na sequencia podemos observar todos os passos de nosso playbook sendo visualizado através das confirmações de nossas “ tasks “, e na última ação ” PLAY RECAP ” ele sempre irá trazer para nós o resumo se foi feito com sucesso e se tivemos alguma alteração baseado na ultima solicitação.

Com isso podemos visualizar nosso arquivo ” .txt ” com toda a configuração atual de nosso equipamento.

Espero que vocês tenham gostado e no proximo post vou demostrar algumas variações que podemos executar dentro dessa lógica de script.

Aguardo comentários. 🙂

Abs,
Rodrigo

Cisco DevNet Webinar – Netacad

Thu, 20 Jul 2017 00:00:00 +0000

Olá Pessoal,

Gostaria de notificar sobre uma nova serie de Webinar que o time Networking Academy está promovendo baseando-se nos novos conceitos que estavamos visualizando sobre “ Progamabilidade “. Esse movimento também vai muito em conjunto com o projeto que esta tendo muita forças que é o DevNet.

Baseando-se nessa filosofia, neste primeiro evento a ideia é justamente explicar um pouco sobre DevNet, o conceito e ferramentas usadas para SDN. Maiores detalhes podem-se visualizados através do site.

Para efetuar seu cadastro no primeiro Webinar que será na proxima quinta-feira dia 27/07 às 13:00hs ( Brazil Time ), você deve fazer seu cadastro através desse link.

Eu estarei lá. Aguardo vocês.

Abs,
Rodrigo

Validação Sintaxe – Ansible

Mon, 15 May 2017 00:00:00 +0000

Olá Pessoal,

Conforme nossas notificações anteriores, hoje gostaria de trazer algumas facilidades que podem ajudar vocês em relação a validação de ” Syntax “. O que seria isso?

Toda linguagem de programação, bem como nossa ” costumeira ” CLI tem sua syntax correta, para que nossos comandos sejam aplicados de forma correta em nossos equipamentos, bem como nesse caso, a lógica seria executar algumas validações em meu script ” Ansible “, para que ele já possa mostrar onde podem estar contidos os erros.

Com isso, vocês podem perceber que o Atom pode trazer diferentes temas e pacotes para customização de seu editor, onde para nosso caso vou trazer 3 pacotes que irá ajudar em suas validações de script. Vale lembrar que esses pacotes que encontrei, foram os que mais me agradam, portanto se alguém que já trabalha com esse editor para desenvolvimento de scripts e tiver mais algumas dica interessante, posta em nossos comentários para que possamos desenvolver juntos as facilidades. 😛

Para procurar os pacotes e fazer a instalação, você deve ir em Edit -> Preferences -> + Install. Logo, você deve visualizar algo conforme nossa figura abaixo:

Após, isso eu recomendo esses três pacotes para que você procure na aba de packages e faça a instalação dos mesmos:

language-ansible
linter-ansible-syntax
linter-js-yaml

Após instalação alguns recursos precisam ser configurados, para que de fato eles possam trabalhar a seu favor. Em dois casos a recomendação é que você faça edição de um arquivo do Atom chamado ( config.cson ), para isso segue os links dos 3 pacotes recomendados acima para que você leia e execute conforme recomendação.

Com isso após estes passos, podemos observar alguns ítens que são inseridos logo abaixo de nossa aplicação dando dicas de possíveis erros em nosso script:

Em nossos dois retângulos azuis, podemos visualizar os alertas que nossos pacotes inserem como notificação e o retângulo laranja a descrição da falha, bem como em que linha ela esta ocorrendo. Desta forma, já conseguimos ter alguma visualização de possíveis erros de digitação, estruturação de variáveis, variáveis sem contéudo, etc.

Como uma última dica e que pode ajudar de alguma forma a visualização da sua indentação, onde pode trazer para você vários problemas, como um espaço adicionado ou até um ” TAB ” executado por engano ( achando que estava na CLI do Cisco…rsrsrs 🙂 ). Para isso devemos novamente ir em Edit -> Preferences -> Editor ( Scroll on ) e você irá visualizar Show Indent Guide. Como em nossa figura:

Você pode visualizar em nosso retângulo azul à esquerda as linhas nas verticais representando o nível de cada argumento que você esta inserindo em seu código.

Espero que vocês tenham gostado dessas dicas e se alguém tiver mais alguma dica fique a vontade em compartilhar. Em nosso próximo post vou iniciar com algumas configurações para captura em nosso CSRV1000V.

Abs,
Rodrigo

Automação – Ansible – DevOps

Mon, 08 May 2017 00:00:00 +0000

Olá Pessoal,

Acredito que baseando-se no título, vocês devem estar se perguntando esse BLOG não é de redes? Sim, ele é de redes, porém, como já venho trazendo em alguns posts anteriores e sempre menciono que nossa área de redes está passando por uma transformação é devido a esses ítens que venho hoje falar um pouco mais para vocês.

Devido a essa novo tema, venho aqui, compartilhar um pouco do que estou estudando para que eu possa melhorar em alguns aspectos, e claro gostaria de mostrar para vocês sobre alguns ítens que possam ajudar nossos engenheiros em nossas tarefas diárias.

Hoje, nosso segmento de redes está trazendo muitos conceitos sobre os processos de automações que devemos implementar, para que nossas tarefas diarias sejam mais efetivas e que nossos scripts não sejam somente atrelados a nossa CLI ( command line interface ) e sim, que nossos scripts possam agregar mais valor as tarefas cotidianas de implementações e que demandam muito esforço repetitivo. Baseando-se nesses tópicos estamos falando-se de duas frentes de trabalho que estão caminhando muito forte dentro do mundo de Redes ( Cisco ) que são Python e Ansible.

Talvez, algumas pessoas podem estar pensando, porque ele já vai falar de Ansible se os temas de Python ainda não forão discutidos ou exemplificados em nosso BLOG. Isso eu vou explicar mais no final de nossa serie de posts sobre Ansible.

Como mencionado anteriormente, nos estamos falando muito em automação dos processos para que seja executado de forma rapida e automatica diversas configurações ou validações em nossos ambientes de redes. Devido a isso, a Cisco está trabalhando fortemente nas disponibilizações de API ( para que não viu, verifique em nosso post de Rest API / API ) e também em formas de trabalhar em conjunto para que essas metodologias de DevOps, seja cada vez mais vivenciado nesse mundo Cisco. Com isso, o que trago para vocês é um detalhamento sobre a linguagem Ansible.

Basicamente, essa linguagem é desenvolvida pela Red Hat, onde eles estão investindo pesado para divulgação dessa linguagem e disponibilizações de soluções para diferentes vendors. Com isso, gostaria de mostrar a documentação do Ansible, para que vocês possam consultar e com certeza através dela muitos ítens podem ser validados, para que você pense em seu primeiro script. Como uma primeira dica, gostaria de deixar um ítem extremamente voltado para nossa área de Redes, especificamente para as demandas que podemos utilizar para equipamentos Cisco, mas também podem observar que temos para diversos fabricantes.

Para efetuar nossos testes eu vou trabalhar com o sistema operacional Linux ( escolhido foi o Ubuntu ) e para maior praticidade, vou utilizar um router virtualizado Cisco CSR1000V. Segue uma topologia bem simples para que vocês entendam o cenario de teste, porém lembrando que esse ambiente pode ser escalado a níveis muito maiores.

Em nosso próximo post, vou explicar um pouco mais sobre a instalação da biblioteca Ansible no Ubuntu e de alguns recursos que vocês podem utilizar para melhorar seu aprendizado. 🙂

Abs,
Rodrigo

Cisco – SandBox

Fri, 17 Mar 2017 00:00:00 +0000

Olá Pessoal,

Conforme havia comentado anteriormente em nosso post sobre DevNet, hoje gostaria de trazer para vocês mais alguns ítens que estão totalmente relacionados a esses novos desenvolvimentos, bem como laboratórios free para que você possa praticar alguns conceitos.

A plataforma Sandbox está disponivel para que você possa usar para desenvolvimento, testar APIs, aprender como configurar um produto, treinamento, hackathons, etc. Dentro desse perfil existe dois módulos que são chamados de ” Always-On ” e ” Reservation “, onde cada um teria sua particularidade:

Always on = Acesso instantâneo sem necessidade de qualquer reserva, acesso completo para as APIs, porém como o acesso é compartilhado com todos os usuários, alguns níveis de privilégios são bloqueados.
Reservation = Necessidade de reservar ambiente, acesso administrativo, ambiente privado, porém existe as policitas que necessita de uma conexão via VPN e as configurações executadas depois de finalizar sua reserva não serão gravadas.

Com isso, você pode testar seu código ou até mesmo visualizar de que forma as novas plataformas estão trabalhando, praticando em alguns casos exemplos de configuração. Neste modelo já existem laboratórios para diversas torres de tecnologia, como abaixo:

Agora as ferramentas já temos disponíveis, apenas precisamos entender esses novos conceitos para praticar e vivenciar um pouco dessa nova experiencia. 🙂

Abs,
Rodrigo

API – DevNet

Thu, 16 Feb 2017 00:00:00 +0000

Olá Pessoal,

Acredito que você tenha lido nosso post anterior sobre API e conforme informado vou trazer alguns ítens que venho acompanhando nessa área que estamos trabalhando ( Routing & Switching e DC ).

Como venho falando em alguns posts anteriores nossa área está alterando-se e devido a isso muitas movimentações estão acontecendo nas organizações para se adequar as novas tendências bem como re-estruturar seus produtos para que os concorrentes não atropelem e definitivamente as marcas não caiam no desuso.

Acredito que vocês souberam da última aquisição da Cisco de uma empresa chamada “ APPDynamics “, pois bem, se observarmos é mais uma empresa tendo seu core business para aplicações. Além disso, podemos observar as ultimas aquisições da Cisco pelo link ( Cisco Acquisition ).

Olhando neste cenário de aquisições da Cisco, qual é a maioria do core business dessas empresas compradas pela Cisco? Se você pensou empresas de software, está correto.

Devido essas novas demandas que estão surgindo exponencialmente, ela como uma gigante não pode ficar esperando ( porém eu achei que ela demorou para acreditar nisso ) que outros fabricantes roubem muito seu mercado, desta forma hoje eles já tem times especificos e uma grande comunidade que está desenvolvendo para que os equipamentos, com sua APIs sejam utilizadas por qualquer desenvolvedor ou fabricante.

Como podem observar pela foto acima Cisco esta trazendo essa menção chamada DevNet, onde já temos o site Developers Cisco, que traz diversas informações relacionados aos desenvolvimento de cada plataforma. Para cada plataforma nós já podemos consultar as APIs publicas baseando-se em cada torre de tecnologia ( Cloud, Networking, Datacenter, etc ).

Se vocês navegarem pelo site, podemos mencionar ainda que não temos muitos ítens disponibilizados para executar as tarefas, mas com certeza eu acredito que isso vai crescer exponencialmente. Vocês acham que isso pode crescer?

Em nosso proximo post vou mencionar um pouco mais sobre o SandBox

Abs,
Rodrigo

O que é API e Rest API?

Mon, 13 Feb 2017 00:00:00 +0000

Olá Pessoal,

Devido as novas demandas que estão surgindo, principalmente a relação de integração de software com nossa infraestrutura ( routers, switches, firewalls ) esses termos mencionados em nosso título acabam sendo evidenciados.

Acredito que todos quando observam esses termos imaginam que isso seja algo relacionado a quem trabalha com programação, integração de sistemas, desenvolvedores de sistemas, etc.

Pois bem, isso não é mais a realidade que vivenciamos em nossa área de redes e infraestrutura. Porquê? 💡

Como todos nos sabemos nossa área esta passando por várias transformações, bem como as empresas estão adicionando em seus produtos muitas funcionalidades que podem ser visualizadas / consultadas por outros fabricantes, com o intuito de oferecer serviços e integrações entre as plataformas. Com isso podemos definir dois ítens:

API ( Application Programming Interface ) : Isso está relacionado a ferramenta ou biblioteca que pode ajudar aos desenvolvedores acessarem informações dentro de seu código ( fabricante ) para fazer a tratativa das informações necessária para o desenvolvimento de sua ferramenta. Essas APIs podem estar contidas nos sistemas operacionais, sistema de banco de dados, hardware de computadores, etc. No caso de uma API podemos mencionar que pensando no protocolo HTTP você poderia fazer um ” GET ” no código para obter as informações.

Como exemplo de uma API poderíamos citar dois exemplos:

Quando acessamos um site onde vamos pesquisar seu endereço e nele temos o mapa do ” Google MAPS ” populados automaticamente na página daquele cliente, e da mesma forma podemos navegar nessa janela olhando pelas ruas próximas ao mapa, ou seja, o site está acessando uma API publica do Google para mostrar aquela informação.
Poderíamos citar sobre o Facebook que disponibiliza uma API para que por exemplo outros software possam fazer uma publicação automatica baseado na sua autorização de utilização da API ( Keys ).

Rest API ( Representational state transfer API ) : Como informado acima API oferece caminhos para que você possa acessar as informações, e quando a menção se torna uma REST API seria quando eu defino funções a qual os desenvolvedores podem executar solicitações e receber respostas por exemplo através do protocolo HTTP ( GET e POST )

Com isso diversas plataforma agora estão vindo com API públicas para que você possa consultar e de alguma forma possa interagir com as ferramentas / hardware que esse fabricante disponibiliza. Você poderia estar pensando o que vou fazer com essas funcionalidades?

Em nosso segundo post vou mencionar sobre o que fazer com essas funcionalidades e como a Cisco está trabalhando com essas novas demandas.

Abs,
Rodrigo

Protocolo VTP – parte 2

Mon, 11 Mar 2013 00:00:00 +0000

Olá Pessoal,

Conforme mencionado anteriormente em nosso post, vamos tratar de explicar como funciona os anúncios de VTP.

Nos sabemos que o equipamento designado como servidor irá publicar as informações para todos os seus vizinhos que estão associados ao mesmo domínio, bem como os outros modos também irão popular as informações e repassar a mensagem para seus vizinhos, fazendo com que todos possam obter a mesma informação.

Essa informação de comparar as alterações está atrelada especificamente ao número de revisão que cada switch possui, ou seja, os switches que estão no mesmo domínio com uma revisão menor irá ser atualizado caso a revisão que esta sendo enviada tenha um valor maior. Nós iremos visualizar as informações através do comando abaixo:

Router#show vtp status
VTP Version: 2
Configuration Revision: 247
Maximum VLANs supported locally: 1005
Number of existing VLANs: 33
VTP Operating Mode: Client
VTP Domain Name: CiscoRedes
VTP Pruning Mode: Enabled
VTP V2 Mode: Disabled
VTP Traps Generation: Disabled
MD5 digest: 0x45 0x52 0xB6 0xFD 0x63 0xC8 0x49 0x80
Configuration last modified by 0.0.0.0 at 8-12-99 15:04:49
Router#

Acima podemos observar diversas informações, como o número de revisão que vai mencionar se todos os switches estão com seu database sincronizado, quantidade de VLANs populadas nesse switch, dominio que pertence esse equipamento e qual o modo de operação que ele esta trabalhando ( cliente ).

Essas mensagens são divulgadas através do link trunk habilitado entre os switches, fazendo com que essas informações sejam propagadas através do 802.1q. Veja abaixo:

Nos temos 3 métodos na qual esses anúncios são enviados:

Sumarizado = São enviados a cada 5 minutos pelo servidor VTP, informa aos switches habilitados para VTP sobre o número de revisão de configuração de VTP atual e são enviados imediatamente após a alteração de qualquer configuração;

Sub-Conjunto = Contém as informações de VLANs e as alterações que vão disparar o anúncio de subconjunto são:

Criação ou exclusão de uma VLAN
Suspensão ou ativação de uma VLAN
Alteração no nome da VLAN
Alteração no MTU da VLAN

Solicitação = É enviado a um servidor VTP no mesmo domínio VTP, o servidor VTP responde enviando um anúncio de sumarização e, em seguida, um anúncio de subconjunto.

O nome de domínio foi alterado
O switch recebe um anúncio de sumarização com um número de revisão de configuração mais alto do que seu próprio número
Uma mensagem de anúncio de subconjunto é perdido por alguma razão
O switch foi reiniciado

Para que possamos definir em que modo de operação ( servidor, cliente, transparente ) o switch vai trabalhar precisamos definir através:

CiscoRedes(config)#vtp mode [server, client, transparent ]

Desta forma podemos concluir sobre o processo de VTP, bem como a divulgação desse protocolo e os modos de configuração que ele pode trabalhar. Lembrando-se que esse protocolo em certas circunstâncias tem um grande valor, porém também é um ponto de falha se formos pensar em segurança, mas vale lembrar que tudo bem planejado pode trazer benefícios e dinamismo para nosso trabalho.

Espero que tenham gostado de mais um tutorial.

Fonte:
VTP Cisco

Abs,
Rodrigo

Protocolo VTP – parte 1

Wed, 26 Dec 2012 00:00:00 +0000

Olá Pessoal,

Hoje iremos falar de um protocolo utilizado em ambientes de rede local, para qual as informações do database de VLAN são transmitidos para todos os equipamentos pertencentes aquela LAN.

O protocolo VTP ( Virtual Trunk Protocol ) é um protocolo da camada 2 utilizado para manter a configuração de VLANs consistentes em uma rede. O VTP é responsável por gerenciar as VLANs, criando, apagando e renomeando as VLANS existentes na rede.

Em uma rede de switches sem o protocolo VTP o administrador de redes deverá manualmente fazer a criação de VLANs em cada um dos switches da rede. O que, dependendo do número de equipamentos e VLANs, pode se tornar uma atividade muito trabalhosa. Além do mais, com uma grande quantidade de configurações necessárias fica mais suscetível o aparecimento de erros na configuração ou erro humano na hora de inserir essas configurações nos equipamentos.

Já com o VTP esse trabalho é reduzido considerávelmente, pois o administrador entrará com as informações em um único swtich, no VTP Server, que terá a função de distribuir e sincronizar essas informações para os outros switches da rede. Além da redução do trabalho esse método evita erros de configuração, uma vez que toda a parte da configuração de criação das VLANs pode ser realizada apenas no switch VTP Server.

Os switches podem trabalhar em 03 modos dentro do VTP, são eles:

VTP Server:
Um VTP server pode criar, deletar e renomear VLANs. Ele também anuncia o nome do domínio VTP, a configuração de VLAN e o número de revisão da configuração para todos os outros switches dentro do domínio VTP.

VTP Client:
Um switch nesse modo não pode criar, nem deletar e nem renomear as VLANs. Dessa forma toda a alteração deve ser feita no VTP server.

VTP Transparent:
Nesse modo o switch precisa ter as suas VLANs configuradas manualmente. Um switch VTP Transparent não participa do VTP e nem anuncia para os vizinhos suas configurações de VLANs.

Esse protocolo tem duas versões, a qual pode gerar incompatibilidade no meio em que os switches estão configurados. Hoje todos os switches vêm com o versão 1 por padrão, sendo assim se desejamos trabalhar com a versão 2 temos que habilitar manualmente, lembrando-se que switches mais antigos não suportam a versão 2, portanto terá que manter a versão 1 funcionando. Para configurar a versão seria:

CiscoRedes#configure terminal
CiscoRedes(config)#vtp version [1 ou 2]

Um outro ponto que deve ser sempre verificado é a senha que pode ser configurada separadamente em cada switch, pois esse parâmetro não é enviado pelos anúncios de VTP, ou seja, se a senha estiver incorreta o seu switch não irá popular as informações do database de VLANs. Para configurar a senha seria:

CiscoRedes#configure terminal
CiscoRedes(config)#vtp password [senha]

Chegando em mais um ponto primordial da configuração do VTP, a qual esta relacionado com o domínio para qual esse anúncios serão notificados, ou seja, para que seu switch armazene as informações ele tem que estar no mesmo domínio, senão você pode perder informações importantes nos anúncios. Para configurar o domínio seria:

CiscoRedes#configure terminal
CiscoRedes(config)#vtp domain [domain-name]

Para exemplificar nosso conteúdo segue uma topologia:

Nesta topologia vamos trabalhar dando exemplos de como será feita a configuração dos equipamentos, bem como entender o que os switches irão armazenar em seu database. Para quem tiver interesse temos um curso básico sobre VTP nesse site da Cisco ( http://www.cisco.com/warp/public/473/vtp_flash/ )

Espero que vocês tenham gostado e no próximo post iremos explicar sobre os anúncios de VTP.

Abs,
Rodrigo