ELK Stack : Shipping metrics data with metricbeat

     Halo semua, pada kesempatan kali ini kami akan share tutorial tentang mengirimkan data metrics dari sebuah server menggunakan metricbeat. Metricbeat adalah beat yang sangat populer yang mengumpulkan dan melaporkan berbagai metrik tingkat sistem untuk berbagai sistem dan platform. Metricbeat juga mendukung modul internal untuk mengumpulkan statistik dari platform tertentu. Anda dapat mengonfigurasi frekuensi Metricbeat mengumpulkan metrik dan metrik spesifik apa yang akan dikumpulkan menggunakan modul dan sub-pengaturan ini yang disebut metricsets. Metric mewakili pengukuran raw penggunaan sumber daya atau perilaku yang dapat diamati dan dikumpulkan di seluruh sistem Anda. Ini mungkin ringkasan penggunaan tingkat rendah yang disediakan oleh sistem operasi, atau dapat berupa jenis data tingkat yang lebih tinggi yang terkait dengan fungsionalitas atau pekerjaan tertentu dari suatu komponen, seperti permintaan yang disajikan per detik atau keanggotaan dalam kumpulan server web. Beberapa metrik disajikan dalam kaitannya dengan kapasitas total, sementara metrik lainnya direpresentasikan sebagai tingkat yang menunjukkan "kesibukan" suatu komponen. Kurang lebih itu penjelasan yang dapat kami ambil, lebih lengkap bisa baca di sini. Untuk langkah-langkahnya sebagai berikut :

1.  Installasi metricbeat 

```bash
$ sudo wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key 
add -
$ sudo echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo 
tee -a /etc/apt/sources.list.d/elastic-7.x.list
$ sudo apt-get update && sudo apt-get install metricbeat
```

2. Konfigurasi metricbeat

```bash
$ sudo cp /etc/metricbeat/metricbeat.yml /etc/metricbeat/metricbeat.yml.origin
$ sudo vi /etc/metricbeat/metricbeat.yml

# berikut adalah contoh untuk send metric dari system dan apache
```
```yaml
metricbeat.modules:
- module: system
  metricsets: ["cpu","memory","network"]
  enabled: true
  period: 15s
  processes: ['.*']
- module: apache
  metricsets: ["status"]
  enabled: true
  period: 5s
  hosts: ["http://10.20.21.23"]
```
```bash
# check apakah index sudah berjalan
$ sudo metricbeat modules enable system
```

3. Atur output dari metricbeat

```bash
# dikirim ke elasticsearch langsung
output.elasticsearch:
  hosts: ["10.20.21.254:9200"]

# dikirim ke logstash
output.logstash:
  hosts: ["10.20.21.254:5044"]
  
# dikirim ke kafka
output.kafka:
  hosts: ["ip_server_kafka:9092"]
  topic: "topicname"
  
# dikirim ke redis
output.redis:
  hosts: ["ip_redis_server:6379"]
  index: "redis.index.for.logstash"
  key: "metricbeat.to.redis"
```

4. Jalankan metricbeat

```bash
# check config untuk verifikasi
$ sudo metricbeat -c /etc/metricbeat/metricbeat.yml test config
$ sudo service metricbeat start
```

5. Verifikasi

```bash
$ curl -XGET '10.20.21.254:9200/_cat/indices?v&pretty'
```

Yaps, sampai jumpa di turorial berikutnya!

Read More

ELK Stack : Shipping logs with filebeat

 

Halo semua, pada kesempatan kali ini kami akan share tentang bagaimana client mengirimkan log ke ELK server, dengan menggunakan filebeat yang merupakan salah satu shipper yang ringan dan banyak digunakan. Untuk environment dari lab kali ini masih sama dengan environmet pada post berikut. Karen bisa dibilang, pada lab ini adalah lanjutannya. Baik, Berikut adalah langkah-langkahnya :

1. Instalasi Filebeat di Ubuntu 18.04

```bash
$ sudo apt -y update

$ sudo wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
$ sudo apt -y install apt-transport-https
$ sudo echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | tee -a /etc/apt/sources.list.d/elastic-7.x.list
$ sudo apt -y update && apt -y install filebeat

$ sudo systemctl enable filebeat
$ sudo systemctl status filebeat
```

2. Konfigurasi pada Logstash

```bash
# pada ELK server

$ sudo vi /etc/logstash/conf.d/filter-syslog.conf

```
```json
filter {
  if [fields][log_name] == "syslog" {
    mutate {
      add_tag => [ "syslog" ]
    }
  }
}
```

```bash
$ sudo systemctl restart logstash
$ sudo systemctl status logstash
```

3. Konfigurasi Filebeat

```bash
$ sudo mv /etc/filebeat/filebeat.yml /etc/filebeat/filebeat.yml.original
$ sudo vi /etc/filebeat/filebeat.yml
```
```yaml
filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /var/log/syslog
  fields:
    log_name: syslog

output.logstash:
  hosts: ["10.20.21.254:5044"]
```

4. Aktifkan layanan filebeat

```bash
$ sudo systemctl restart filebeat
$ sudo systemctl status filebeat
```

5. Verifikasi

```bash
$ curl http://10.20.21.254:9200/_cat/indices?v
```

6. Atur dashboard

```bash
# Klik Menu Management > Elasticsearch > Index Management
# Membuat Index Pattern
# Klik Menu Management -> Kibana -> Index Patterns
# Klik Create Index Pattern
# Index Pattern Name: syslog_*
# Klik Next Step
# Time Filter field name: @timestamp
# Klik Create Index Pattern
```

Yaps, sampai jumpa di tutorial berikutnya! 

Read More

ELK Stack : Elasticsearch, Logstash and Kibana Installation

 

Halo semua, pada kesempatan kali ini kami akan mulai untuk tutorial dari ELK stack ini. Pada sesi kali ini akan dimulai dengan Installasi dari ELK stack, bagi yang belum paham komponen dan penjelasan tentang ELK, Bisa tengok di postingan berikut. Disana akan menjadi landasan sebelum kita melakukan praktek, agar paham apa saja komponen dan fungsinya. Oke, Sebelum masuk ke langkah-langkah percobaan, kita akan tunjukan environment dari lab kita nantinya.

 - ELK stack Server : 

|     Hostname   | pod0-elk |
| ----------- | ----------- |
| IP Adress   | 10.20.21.254|
| OS | Ubuntu 18.04 |
| Ram | 4GB |

- Client Server/ Beat

|     Hostname   | pod1-elk |
| ----------- | ----------- |
| IP Adress   | 10.20.21.253|
| OS | Ubuntu 18.04 |
| Ram | 512MB |

Pada lab ini, kami menggunaka Ubuntu 18.04, pada semua node/podnya. Tapi dalam penerapannya baik client/server dapat menggunakan sistem operasi lainya. Lengkapnya untuk support dari ELK dapat di check di sini. Jika environment sudah siap, mari kita lanjut ke langkah-langkah percobaan berikut :

Install ElasticSearch

1.  Update repository

```bash
$ sudo apt -y update
```

2.  Install dependensi

```bash
$ sudo apt -y install openjdk-8-jdk
$ java -version
```

3.  Install ElasticSeach

```bash
$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
$ sudo apt -y install apt-transport-https
$ echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | tee -a /etc/apt/sources.list.d/elastic-7.x.list
$ sudo apt -y update && apt -y install elasticsearch
```

4.  Konfigurasi ElasticSearch

```bash
$ cp /etc/elasticsearch/elasticsearch.yml /etc/elasticsearch/elasticsearch.yml.original
$ vi /etc/elasticsearch/elasticsearch.yml
```
```yaml
# cari bagian berikut dan uncoment atau hilangkan pagar didepanya
# lalu ganti localhost dengan ipaddress dari server
network.host: 10.20.21.254
network.port: 9200
# tambahkan juga, karena jika kita runing dengan host berupa IP, 
# dianggap production jadi perlu kita set tipe discover
discovery.type: single-node
```

5.  jalankan ElasticSearch

```bash
$ sudo systemctl daemon-reload
$ sudo systemctl enable elasticsearch
$ sudo systemctl start elasticsearch
$ sudo systemctl status elasticsearch
```

6.  Verifikasi

```bash
$ netstat -tupln
$ curl -XGET 'localhost:9200/?pretty'
$ curl -XGET '10.20.21.254:9200/?pretty'
```

Install LogStash

1.  Installasi Logstash

```bash
$ sudo apt -y install logstash
```

2.  Konfigurasi Logstash

```bash
$ sudo vi /etc/logstash/conf.d/input-filebeat.conf
```
```bash
input {
  beats {
    port => 5044
  }
}
```

3.  Membuat Output dari Logstash

```bash
$ sudo vi /etc/logstash/conf.d/output-elasticsearch.conf
```
```bash
output {
  elasticsearch {
    hosts => ["10.20.21.254:9200"]
    manage_template => false
    index => "%{[fields][log_name]}_%{[agent][hostname]}_%{+YYYY.MM}"
  }
}
```

4.  Jalankan Logstash

```bash
$ sudo systemctl enable logstash
$ sudo systemctl start logstash
$ sudo systemctl status logstash
$ netstat -tupln
```

Install Kibana

1.  Installasi Kibana

```bash
$ sudo apt -y install kibana
```

2.  Konfigurasi dan integrasi dengan ElasticSearch

```bash
$ sudo cp /etc/kibana/kibana.yml /etc/kibana/kibana.yml.original
$ sudo vi /etc/kibana/kibana.yml
```
```bash
server.port: 5601
server.host: "10.20.21.254"
elasticsearch.hosts: ["http://10.20.21.254:9200"]
```

3.  Jalankan Kibana

```bash
$ sudo systemctl enable kibana
$ sudo systemctl start kibana
$ sudo systemctl status kibana
```

4.  Installasi nginx dan konfigurasi

```bash
$ sudo apt -y install nginx apache2-utils
$ sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/default.original
$ sudo vi /etc/nginx/sites-available/default
```
```bash
#hapus semua dan ganti seperti berikut
server {
    listen 80;

    server_name _;

    auth_basic "Restricted Access";
    auth_basic_user_file /etc/nginx/htpasswd.kibana;

    location / {
        proxy_pass http://localhost:5601;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}
```

5.  Buat user dan jalankan Nginx

```bash
# ganti [username] dengan username yang akan kita gunakan
$ sudo htpasswd -c /etc/nginx/htpasswd.kibana [username]
$ sudo systemctl enable nginx
$ sudo systemctl restart nginx
$ sudo systemctl status nginx
$ netstat -tupln
```

6. Verifikasi

Coba untuk akses via browser

Yaps, diatas adalah installasi ELK stack, untuk install beat akan dibahas pada tutorial berikutnya, sampai jumpa!

Read More

ELK Stack : What is ELK? (ElasticSearch , Logstash , Kibana)

 

    Halo semua, pada kesempatan kali ini, kami akan share tentang salah satu tools monitoring yang banyak digunakan, yaitu ELK Stack. Stack ini menjadi kesatuan karena biasa digunakan untuk monitoring menjadi satu paket, walaupun pada aslinya berbebeda aplikasi. Dan kali ini kami akan share beberapa hal tentang hal tersebut. Elasticsearch, Logstash dan Kibana adalah tool yang berguna untuk mengumpulkan log dan juga menvisualisasi,Elasticsearch berguna untuk menyimpan semua log yang berasal dari server, Logstash merupakan sebuah perangkat lunak open source untuk mengumpulkan dan memparsing log dan juga membuat index untuk log, kemudian disimpan pada elasticsearch. Kibana adalah web interface yang berguna untuk menampilkan log baik dalam bentuk grafik maupun visualisasi lainnya. untuk file agent di perlukan filebeat yang berguna untuk mengirim log dari setiap server kepada logstash. 

    Kenapa perlu untuk memusatkan log ?. Karena, Log yang tersentralisasi sangat berguna jika suatu saat seorang DevOps akan melakukan identifikasi masalah pada server atau aplikasi. Hal tersebut membuat mereka mampu mencari histori data atau log, intinya memudahkan dalam proses monitoring dan juga troubleshooting. 

Dan berikut adalah komponen dari ELK Stack :

-  Elasticsearch : Bertugas untuk menyimpan semua log.

-  Logstash        : Bertugas untuk memproses log dan membuat index log.
-  Kibana       : Sebagai Web interface untuk mencari dan memvisualisasikan log baik dalam grafik yang di inginkan

Sedangkan untuk yang berikut adalah opsional :
- Filebeat          : Berfungsi mengirim log ke logstash. Berfungsi sebagai shipping agent untuk log. Menggunakan lumberjack networking protocol untuk berkomunikasi dengan logstash. Filebeat akan dipasang di server yang mempunyai log (yang akan diproses).

Untuk filebeat ini kenapa bersifat opsional, karena dapat digantikan dengan agent lain, karena si filebeat ini bertugas mengirimkan log dari sisi client  yang akan dimonitor. Untuk penggambarannya dapat dilihat seperti diagram berikut :

Untuk check beberapa agent yang bisa dipakai atau recomended  bisa check di sini, Untuk melihat beberapa daftar beatsnya . [source]

Yaps, sampai jumpa di postingan berikutnya!

Read More

Docker : Deploy python app with Docker compose

 Halo semua, pada kesempatan kali ini. Kami akan share tutorial medeploy aplikasi python dengan menggunakan docker compose, kalau kita sebelumnya deploy wordpress dengan docker compose, kali ini kita coba deploy aplikasi buatan kita yang menggunakan bahasa pemogram python pada contoh kali ini, untuk langkah-langkahnya sebagai berikut :

1. Buat folder proyek

```bash
$ mkdir my_app; cd my_app
```

2. Buat file aplikasi

```bash
$ vim app.py
```

```python
import time

import redis
from flask import Flask


app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)


def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)


@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0", debug=True)
```

3. Buat file requirement

```bash
$ vim requirements.txt
```
```plaintext
flask
redis
```

4. Buat Dockerfile untuk image

```bash
$ vim Dockerfile
```
```bash
FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]
```

5. Buat docker compose untuk konfigurasi

```bash
$ vim docker-compose.yml
```
```yaml
version: '3.2'
services:
  web:
    build: .
    ports:
     - "5000:5000"
    volumes:
     - .:/code
  redis:
    image: "redis:alpine"
```

6. Jalankan docker compose

```bash
$ sudo docker-compose up -d
```

7. verifikasi

```bash
$ curl http://localhost:5000

# check docker-compose aktif
$ sudo docker-compose ps
# check environment aplikasi
$ sudo docker-compose run web env
```

Kalau kita check via browser

8. Hapus aplikasi

```bash
$ sudo docker-compose down --volumes
```

Yaps, sampai jumpa di tutorial berikutnya !

Read More

Docker : Deploy Wordpress app with Compose

 Halo semua, pada kesempatan kali ini kami akan berbagi contoh penerapan dari docker compose dalam membangun sebuah aplikasi, pada contoh kali ini kami akan membangun aplikasi wordpress dengan metode docker compose. Berikut adalah langkah-langkah yang dilakukan :

1. Buat Folder proyek

```bash
$ mkdir /my_wordpress ;cd /my_wordpress
```

2. Buat file konfigurasi docker compose

```bash
$ vim docker-compose.yml
```
```yaml
version: '3.2'

services:
   db:
     image: mysql:5.7
     volumes:
       - dbdata:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: somewordpress
       MYSQL_DATABASE: wordpress
       MYSQL_USER: [username]
       MYSQL_PASSWORD: [password]

   wordpress:
     depends_on:
       - db
     image: wordpress:latest
     ports:
       - "8000:80"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306
       WORDPRESS_DB_USER: [username]
       WORDPRESS_DB_PASSWORD: [password]
volumes:
    dbdata:
```
```bash
# catatan untuk [username] dan [password] bisa dirubah dengan kebutuhan kita(bebas)
# kalau default seperti [username] dan [password] akan error saat docker-compose di up
```

3. jalankan docker compose

```bash
$ sudo docker-compose up -d
# jika terjadi error saat pull image, biasanya masalah authentikasi silahkan login ke docker hub dengan cara berikut
$ docker login
# masukan username(docker id) dan password
```

4. verifikasi

```bash
$ sudo docker container ls
```

5. hapus aplikasi

```bash
$ sudo docker-compose down --volumes
```

Yaps, sekian dulu. sampai jumpa di tutorial berikutnya!

Read More

Docker : Docker compose installation

 

Halo semua, pada kesempatan kali ini kami akan berbagi tutorial tentang Docker compose.  Sebelum beranjak ke langkah berikutnya, kita akan review sedikit apa itu docker compose dan bedanya dengan docker biasa. Compose adalah tools untuk mendefinisikan dan menjalankan aplikasi Docker multi-container. Dengan hanya menulis di file konfigurasi,  file digunakan untuk mengonfigurasi layanan aplikasi kita yang berjalan di docker. Kemudian, dengan menggunakan satu perintah, kita dapat membuat dan memulai semua layanan dari konfigurasi tadi. Kurang lebih seperti itu jika kita mengarah kepada pengertian yang ada pada halaman resminya. Jadi, intinya sesuai dengan logo dari docker compose yaitu gurita yang memegangf banyak container , kurang lebih seperti itu. Dengan docker compose  kita dapat menjalankan  banyak container yang saling terhubung hanya dengan menuliskannya pada file konfigurasi dan menjalankannya dengan sekali perintah. Dan jika ada perubahan kita dapat mengubahnya langsung pada file konfigurasi lalu menjalankan ulang(restart) docker composenya. Dan berikut adalah cara untuk installasasinya, untuk contoh penerapannya, ada di tutorial berikut.

1. Mengunduh docker compose

```bash
$ sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
```

2. Mengatur permission dari docker compose

```bash
$ sudo chmod +x /usr/local/bin/docker-compose
```

3. Verifikasi 

```bash
$ sudo docker-compose --version
```

Yaps, sekian dulu. sampai jumpa di tutorial berikutnya!

Read More

Docker : Secrets

Halo semua, pada kesempatan kali ini kami akan berbagi sedikit tentang secret pada docker. Diantara manfaat dari secret ini adalah untuk menyimpan informasi yang sifatnya sensitif, seperti password, token, dan sebagainya. Kurang lebih itu adalah beberapa manfaat implentasi dari secret. Dan berikut adalah langkah-langkah untuk labnya :

1. Membuat secret

```bash
$ printf "This is a secret" | sudo docker secret create my_secret -
```

2. Membuat service redis dan mengizinkan akses terhadap secret yang sudah dibuat

```bash
$ sudo docker service  create --name redis --secret my_secret redis:alpine
```

3. Verifikasi service redis

```bash
$ sudo docker service ps redis
```

4. Baca content di dalam container

```bash
$ sudo docker ps --filter name=redis -q
$ sudo docker container exec $(docker ps --filter name=redis -q) ls -l /run/secrets
$ sudo docker container exec $(docker ps --filter name=redis -q) cat /run/secrets/my_secret
```

5. Verifikasi secret tidak ada di image hasil commit container

```bash
$ sudo docker commit $(docker ps --filter name=redis -q) committed_redis
$ sudo docker run --rm -it committed_redis cat /run/secrets/my_secret
```

6. Menghapus akses service redis dari secret

```bash
$ sudo docker service update --secret-rm my_secret redis
```

7. Verifikasi service redis sudah tidak ada akses

```bash
$ sudo docker container exec $(docker ps --filter name=redis -q) ls -l /run/secrets
```

8. Hapus secret dan service

```bash
$ sudo docker service rm redis
$ sudo docker secret rm my_secret

# sebagai catatan : untuk menghapus secret perlu dipastikan tidak ada service yang akses terhadap secret tersebut
# untuk menghapus akses bisa dilihat di langkah nomor 6
```

Yaps, sekian dulu, sampai jumpa di tutorial berikutnya!

 

Read More

Docker : Overlay Network Without Swarm

 

Halo semua, pada kesempatan kali ini kami akan berbagi tutorial tentang overlay network tanpa docker swarm. Seperti kita tahu bahwa swarm ini adalah orchestration tool, yang memungkinkan kita untuk deploy container di multihost. Jadi memang satu tipe dengan kubernetes. Tapi pada kesempatan kali ini kita tidak akan menggunakan swarm, dalam menggunakan overlay network. Pertama mari kita samakan persepsi dulu, overlay network pada pembahasan ini mengacu pada menghubungkan antar container yang berada pada host/node yang berbeda satu sama lain. Untuk environment lab kali ini kita akan menggunakan lebih dari satu host/node, mengaju pada lab berikut, Dengan tambahan 1 host/node lagi, jadi detailnya sebagai berikut :

    - pod0-docker ( IP : 10.20.21.254 )

    - pod1-docker ( IP : 10.20.21.253 )

    - pod2-docker ( IP : 10.20.21.252 )

Dengan masing-masing host/node sudah terinstall docker, berikut adalah langkah-langkahnya :

1. Di pod0-docker, jalankan key-value store consul

```bash
$ sudo docker run -d -p 8500:8500 -h consul --name consul progrium/consul -server -bootstrap
```

2. Di pod1-docker dan pod2-docker, matikan service docker dan jalankan docker dari CLI

```bash
$ sudo systemctl stop docker
$ sudo systemctl status docker
$ sudo /usr/bin/docker daemon -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --cluster-advertise ens3:2375 --cluster-store consul://10.20.21.254:8500 &
```

3. Di pod1-docker atau pod2-docker, buat overlay network

```bash
# pad contoh ini saya buat di pod2-docker
$ sudo docker network create -d overlay --subnet=10.0.0.0/24 my-overlay
$ sudo docker network ls
```

4. Di pod1-docker, buat container alpine1 terhubung ke network my-overlay

```bash
$ sudo docker run -dit --name alpine1 --network my-overlay alpine ash
```

5. Di pod2-docker, buat container alpine2 terhubung ke network my-overlay

```bash
$ sudo docker run -dit --name alpine2 --network my-overlay alpine ash
```

6. Di pod2-docker, tampilkan detil network my-overlay

```bash
$ sudo docker network inspect my-overlay
```

7. Di pod2-docker, masuk ke container alpine2 dan uji ping ke alamat ip dan nama container alpine1 (sukses)

```bash
$ sudo docker attach alpine2
$ ping -c 3 10.0.0.x
$ ping -c 3 alpine1

# x pada IP di atas, sesuai dengan ip pada alpine1
```

Sampai di sini jika berhasil(sukses), berarti kita sudah mencapai tujuan untuk menggunakan overlay network tanpa swarm. Dan langkah berikut digunakan Membersihkan hasil lab dan mengembalikan ke kondisi awal.

8. Di pod1-docker, hapus container alpine1, matikan command docker dan nyalakan service docker

```bash
$ sudo docker container rm -f alpine1
$ sudo ps -aux | grep docker | head -1
$ sudo kill [PID COMMAND DOCKER]
$ sudo systemctl start docker
$ sudo systemctl status docker
```

9. Di pod2-docker, hapus container alpine2, hapus network my-overlay, matikan command docker dan nyalakan service docker

```bash
$ sudo docker container rm -f alpine2
$ sudo docker network rm my-overlay
$ sudo ps -aux | grep docker | head -1
$ sudo kill [PID COMMAND DOCKER]
$ sudo systemctl start docker
$ sudo systemctl status docker
```

10. Di pod0-docker, hapus key-value store consul

```bash
$ sudo docker rm -f consul
```

Yaps, sekian dan sampai jumpa di tutorial berikutnya!

Read More

Docker : Host Network

 Halo semua, pada kesempatan kali ini kami akan berbagai tutorial tentang host network, masih berhubungan dengan networking pada docker, bagi yang belum baca bisa mampir di mari. Jadi intinya host network ini adalah kita menjalankan container pada jaringan di level host. Ini berarti ketika kita menjalankan container , container tersebut dapat kita akses dengan menggunakan alamat IP dari host/ server yang menjalankan docker. Pada contoh berikut kita akan coba menjalankan container dengan aplikasi web server, yaitu nginx, lalu kita dapat mengaksesnya dengan menggunakan ip address dari host. Berikut adalah langkah-langkahnya:

1. Menjalankan container

```bash
$ sudo docker run --rm -itd --network host --name my_nginx nginx
```

2. Verifikasi via browser atau cli

```bash
$ curl http://localhost
```

3. Verifikasi alamat IP dan bound port 80

```bash
$ ip add
$ sudo netstat -tulpn | grep :80
```

4. Hentikan container

```bash
$ sudo docker container stop my_nginx
```

Yaps, sekian dulu untuk kesempatan kali ini, sampai jumpa di tutorial berikutnya!

Read More

Docker : User-Defined Bridge Network

 

Hallo semua, pada kesempatan kali ini kami akan share tentang bagaimana caranya kita membuat network pada docker. Sebelum belajar tutorial ini, baiknya untuk membaca post berikut. Harapanya agar dapat memahami terlebih dahulu tentang networking pada docker. Berikut adalah langkah-langkahnya :

1. Membuat bridge network dengan nama mynetwork

```bash
$ sudo docker network create --driver bridge mynetwork
```

2. Menampilkan daftar network 

```bash
$ sudo docker network ls

# pastikan ada network dengan nama mynetwork
```

3. Melihat deskripsi dari network mynetwork

```bash
$ sudo docker network inspect mynetwork
```

4. Membuat 3 container 

```bash
# networking pada network sebagai berikut :
# alpine1 terhubung ke default bridge
# alpine2 terhubung ke mynetwork
# alpine3 terhubung ke 2 network

$ sudo docker run -dit --name alpine1 alpine ash
$ sudo docker run -dit --name alpine2 --network mynetwork alpine ash
$ sudo docker run -dit --name alpine3 alpine ash
$ sudo docker network connect mynetwork alpine3
$ sudo docker container ls

```

5. Tampilkan detail network bridge dan mynetwork

```bash
$ sudo docker network inspect bridge
$ sudo docker network inspect mynetwork
```

6. Masuk ke container dan test koneksi antar container

```bash
$ masuk ke alpine3 dan test
$ sudo docker attach alpine3

# ping ke IP alpine1
$ ping -c 3 172.17.YYY.YYY
$ ping -c 3 alpine1
$ ping -c 3 alpine2

# masuk ke alpine2
# test ping ke IP alpine1
$ sudo docker attach alpine2
$ ping -c 3 172.17.YYY.YYY
$ ping -c 3 8.8.8.8
```

7. Menghapus network dan container

```bash
# hapus hasil lab
$ sudo docker container rm -f alpine1 alpine2 alpine3
$ sudo docker network rm mynetwork
```

Yaps, sampai di sini dulu, sampai ketemu di tutorial berikutnya!

Read More

Docker : Networking on Docker

 

Hallo semua, pada kesempatan kali ini kami akan share tentang Networking yang ada pada docker.  Pada docker sendiri ada 4 tipe network yang disediakan yaitu :

1. bridge, tipe ini adalah default network. Docker menyambungkan container ke network ini secara default, kecuali memilih opsi driver yang berbeda ketika menjalankan docker run --network=<NETWORK>
2. none, container tidak memiliki network inteface.
3. host, container yang berada pada jaringan host. Tidak ada batasan antara container dan host. Port yang ada dibuka pada host bisa diakses langsung oleh container, begitu juga sebaliknya.
4. macvlan, network ini mengizinkan pembuatan alamat MAC (alamat fisik network)

Sedangkan, dari network-network di atas, disinggung bahwa secara default emang akan menggunakan tipe bridge, seperti gambar berikut :

 

Kurang lebih, di Atas Adalah arsitektur network bridge, yang secara default di attach pada container, ketika menjalankannya tanpa opsi tambahan network. Berikut adalah beberapa perintah dasar, yang berhubungan dengan network yang ada pada docker :

1 . Menanmpilkan Network yang ada

```bash
$ sudo docker network ls
```

2. Melihat Deskripsi lengkap network

```bash
$ sudo docker network inspect bridge

# memfilter output
# contoh jika hanya menampilkan IP
$ sudo docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' [CONTAINER NAME / ID]
```

3. Menyambungkan Contianer ke network

```bash
$ sudo docker network connect [NETWORK NAME] [CONTAINER NAME]
```

4. Memutus sambungan container  ke network

```bash
$ sudo docker network disconnect [NETWORK NAME] [CONTAINER NAME]
```

5. Menghapus network

```bash
$ sudo docker network rm [NETWORK NAME]
```

Yaps, sekian tutorial sederhana kali ini, sampai jumpa di tutorial berikutnya!

Read More

Docker : Share volume

 

Hallo semua, pada kesempatan kali ini kami akan share tentang bagaimana caranya container menggunakan volume dari remote host. Untuk yang belum tau volume pada docker bisa coba tutorial berikut. Untuk environment dari tutorialnya sebagai berikut :

- pod0-docker  ( IP : 10.20.21.254)

- pod1-docker (volume, IP : 10.20.21.253)

Kurang lebih kita di sini menggunakan dua vm atau 2 server, yang masing-masing terinstall docker. Untuk langkahnya seperti berikut :

1. Login ke pod1-docker, dan buat folder yang akan digunakan sebagai volume

```bash
# ada di pod1-docker
$ sudo mkdir /share
$ sudo chmod 777 /share
$ exit
```

2. Login ke pod0-docker, untuk install plugin

```bash
# ada di pod0-docker
$ sudo docker plugin install --grant-all-permissions vieux/sshfs
$ sudo docker plugin ls
$ sudo docker plugin disable [PLUDIN ID]
$ sudo docker plugin set vieux/sshfs sshkey.source=/root/.ssh/
$ sudo docker plugin enable [PLUDIN ID]
$ sudo docker plugin ls

# [PLUGIN ID] di temukan setelah menampilkan daftar plugin
```

3. Membuat volume  ke pod1-docker dari pod0-docker

```bash
# ada di pod0-docker
$ sudo docker volume create --driver vieux/sshfs -o sshcmd=root@10.20.21.253:/share  -o allow_other sshvolume
```

4. Coba menjalankan container dengan attach volume yang sudah dibuat

```bash
# ada di pod0-docker
$ sudo docker run -d --name=nginxtest-ssh -p 8090:80 -v sshvolume:/usr/share/nginx/html nginx:latest
```

5. Verifikasi, dengan buat file di folder share yang ada di pod1-docker

```bash
# ada di pod1-docker
# coba buat file di folder share
$ sudo sh -c "echo 'Hello, I am sulaiman' > /share/index.html"
$ sudo cat /share/index.html
exit
```

```bash
# ada di pod0-docker
# verifikasi content yang tampil sesuai
$ sudo docker ps
$ curl http://localhost:8090
```

Yaps, sampai disini dulu tutorial kali ini, sampa jumpa di tutorial berikutnya!

Read More

Docker : Create a volume and assign it to the container

 

Hallo semua, pada kesempatan kali ini kami akan share tutorial tentang volume pada docker, fungsi dari volume  disini adalah untuk menghubungkan folder pada host dan folder pada container, jadi singkatnya kita mengshare folder pada host  ke container. Berikut adalah langkah-langkahnya :

1. Buat volume

```bash
$ sudo docker volume create my-vol
```

2. Menampilkan volume yang ada

```bash
$ sudo docker volume ls
```

3. Menampilkan deskripsi dari volume

```bash
$ sudo docker volume inspect my-vol
```

4. Menjalankan container dengan volume

```bash
$ sudo docker run -d --name=nginxtest -v my-vol:/usr/share/nginx/html nginx:latest

# jalankan dengan volume read only
$ sudo docker run -d --name=nginxtest-rovol -v my-vol:/usr/share/nginx/html:ro nginx:latest
```

5. verifikasi

```bash
# check ip address container
$ sudo docker inspect nginxtest | grep -i ipaddress

# check content
$ curl http://172.17.XXX.XXX

# tambah content pada volume
$ sudo echo "Content dari volume." > index.html
$ sudo mv index.html /var/lib/docker/volumes/my-vol/_data

# check ulang
$ curl http://172.17.XXX.XXX
```

6. Jalankan container dengan volume tanpa buat terlebih dahulu

```bash
$ sudo docker run -it --name my-vol2 /test_vol nginx:latest /bin/bash

# /test_vol adalah folder pada container sebagai mounting folder
# untuk check file2 yang ada, pada host check di /var/lib/docker/volumes/my-vol2/_data
```

Yaps, sekian dulu untuk tutorial pada kesempatan ini, sampai jumpa di tutorial berikutnya!

Read More

Docker : publish our image to Docker hub

 

    Hallo semua, pada kesempatan kali ini, kami akan share tentang bagaimana caranya untuk mempublish image yang sudah kita buat ke container registry yang pada kesempatan kali ini adalah docker hub, yaitu container registry  yang di sediakan oleh docker. Sebelum itu perlu kita bahas sedikit apa itu container registry. Container Registry adalah tempat terpusat bagi tim Anda untuk mengelola image Docker, menjalankan analisis kerentanan, dan menentukan siapa yang dapat mengakses dengan kontrol akses yang terperinci. Kurang lebih gitu pengertiannya. Intinya adalah tempat untuk menampung image yang sudah kita atau tim kita buat, agar dapat diakses dari manapun, dengan akses yang ditentukan, atau publik(semua orang bisa memakainya). Berikut adalah langkah-langkahnya, untuk yang belum membaca  bagaimana caranya buat image dari Dockerfile  bisa mampir di sini. Oke, Berikut adalah langkahnya :

1. Login dengan Docker ID

Jika belum ada akun bisa daftar di sini

```bash
$ sudo docker login
```

2. Tag image

```bash
$ sudo docker tag friendlyhello [USER]/docker_train:latihan02
```

3. Tampilkan image yang sudah dibangun

```bash
$ sudo docker image ls
```

4. push image ke repo

```bash
$ sudo docker push [USER]/docker_train:latihan02
```

5. Uji jalankan image

```bash
$ sudo docker run -d -p 4000:80 [USER]/docker_train:latihan02
```

6. Tampilkan container Up

```bash
$ sudo docker container ls
```

7. Uji browsing app

```bash
$ curl http://localhost:4000
```

8. check via docker hub

login ke docke hub, lalu akan muncul 

Yaps, sekian dulu, sampai jumpa di tutorial berikutnya!

Read More

Docker : Create image with Dockerfile (Lab 2)

 Hallo semua, Pada kesempatan kali ini kami akan share kelanjutan tentang Dockerfile yang kedua, jika belum melihatnya bisa mampir kesini. Langsung saja, berikut adalah langkah-langkahnya :

1. Membuat folder proyek

```bash
$ sudo mkdir -p /docker_train/latihan02
$ cd /docker_train/latihan02
```

2. Membuat Dockerfile

```bash
$ vim Dockerfile
```

```html
# menggunakan source image
FROM python:2.7-slim

# mengatur folder default app
WORKDIR /app

# menambahkan file yang ada di folder proyek ke dalam folder app image
ADD . /app

# Install package dari file konfigurasi tambahan
RUN pip install --trusted-host pypi.python.org -r requirements.txt

# Expose port untuk aplikasi
EXPOSE 80

# Mendefinisikan variabel
ENV NAME World

# Menjalankan program ketika container dijalankan
CMD ["python", "app.py"]
```

3. Buat file tambahan untuk aplikasi

```bash
$ vim requirements.txt

Flask
Redis
```

```bash
$ vim app.py
```

```python
from flask import Flask
from redis import Redis, RedisError
import os
import socket

# Connect to Redis
redis = Redis(host="redis", db=0, socket_connect_timeout=2, socket_timeout=2)

app = Flask(__name__)

@app.route("/")
def hello():
    try:
        visits = redis.incr("counter")
    except RedisError:
        visits = "cannot connect to Redis, counter disabled"

    html = "
Hello {name}!
" \
           "Hostname: {hostname}
" \
           "Visits: {visits}"
    return html.format(name=os.getenv("NAME", "world"), hostname=socket.gethostname(), visits=visits)

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80)
```

4. Bangun image dari Dockerfile

```bash
$ sudo docker build -t friendlyhello .
```

5. Tampilkan image yang sudah dibuat

```bash
$ sudo docker image ls
```

6. Menjalankan container  dengan image yang sudah dibuat

```bash
$ sudo docker run -d -p 4000:80 friendlyhello
$ curl http://localhost:4000
```

Yaps, sekian dulu tutorial kali ini, sampai jumpa di tutorial berikutnya!

Read More

Docker : Create image with Dockerfile

 Hallo semua, pada kesempatan kali ini kami akan share tutorial tentang, bagaimana membuat image  sendir pada docker. Fungsi dari custom image ini sendiri adalah mempack image yang berisi program/file yang sesuai dengan kebutuhan kita. Misalkan kita ingin membuat image web server yang ketika dijalankan otomatis menggunakan template dari aplikasi kita, dan sebagainya. Berikut adalah langkah-langkahnya :

1. Membuat folder proyek

```bash
$ sudo mkdir -p /docker_train/latihan01
$ sudo chown -R ubuntu:ubuntu /docker_train
cd /docker_train/latihan01
```

2. Membuat Dockerfile

```bash
$ vim Dockerfile
```

```html
# menggunakan image source
FROM docker/whalesay:latest

# Install applikasi
RUN apt -y update && apt install -y fortunes

# Execute command
CMD /usr/games/fortune -a | cowsay
```

3. Bangun image dari Dockerfile

```bash
$ sudo docker build -t docker-whale .
```

4. Tampilkan hasil image yang dibuat

```bash
$ sudo docker image ls
```

5. Uji jalankan image

```bash
$ sudo docker run docker-whale
```

Yaps, sampai jumpa lagi di Tutorial berikutnya!

Read More

Docker : Basic Command in docker

 Hallo semua, pada kesempatan kali ini, kami akan share beberapa tutorial tentang perintah dasar pada docker, berikut adalah beberapa perintah dasar tersebut :

1. menjalankan container

```bash
$ docker run hello-world

# bisa juga dengan opsi

$ docker run --name nama_container hello-world

# untuk melihat beberapa opsional pada docker
$ docker run --help
```

2. melihat container

```bash
# melihat container yang sedang berjalan
$ docker container ls

# untuk melihat semua, baik yang berjalan ataupun sudah berhenti
$ docker container ls -a
```

3. melihat proses 

```bash
# melihat proses yang berlajan
$ docker ps
# melihat semua proses
$ docker ps -a
```

3. melihat image yang ada pada server kita atau sudah terdownload

```bash
$ docker image ls

# atau

$ docker images
```

4. Menghapus pada docker 

```bash
# hapus container
$ docker rm [container_id / container_name]
# atau 
$ docker container rm [container_id / container_name]

# hapus image
$ docker rmi [image_id / image_name]
# atau
$ docker image rm [image_id / image_name]

# hapus semua
$ docker container prune 
$ docker image prune

# dengan catatan terhapus semua yang tidak terpakai
```

Yaps, mungkin segitu dulu tutorialnya, sampai jumpa di tutorial berikutnya!

Read More

Docker : How to install docker in linux

 

Hallo semua, pada kesempatan kali ini kita akan belajar tentang installasi docker pada sistem operasi Linux, dengan contoh di beberapa distribusi linux :

1. Install di Centos

```bash
# setup repository
$ sudo yum install -y yum-utils

$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

```

```bash
# install docker
$ sudo yum install docker-ce docker-ce-cli containerd.io
```

2. Install di Debian

```bash
# update package dan depedensi

$ sudo apt-get update
$ sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

```

```bash
# add gpg key
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
$ sudo apt-key fingerprint 0EBFCD88

# add repo

# untuk x86_64 / amd64

$ sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"

# untuk armhf
$ sudo add-apt-repository \
   "deb [arch=armhf] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"

# untuk arm64
$ sudo add-apt-repository \
   "deb [arch=arm64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"

# standarnya menggunakan x86_64 / amd64
```

```bash
# install docker
$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io
```

3. Install di Fedora

```bash
# add repository
$ sudo dnf -y install dnf-plugins-core
$ sudo dnf config-manager \
    --add-repo \
    https://download.docker.com/linux/fedora/docker-ce.repo
```

```bash
# install docker
$ sudo dnf install docker-ce docker-ce-cli containerd.io
```

4. Install di Ubuntu

- install dari repo docker.com

```bash
# install dari repo resmi docker.com
# install dependensi
$ sudo apt-get update
$ sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

# tambahkan key
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
$ sudo apt-key fingerprint 0EBFCD88

# add repo

$ sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

# install docker
$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io
```

- Install dari repo resmi ubuntu

```bash
$ sudo apt -y install docker.io 
```

5. Verifikasi

```bash
$ sudo docker info
$ sudo docker version

# jika non-root user
$ docker info
$ docker version
```
Jika kita hendak menjalankan docker dengan non-root user, perlu menambahkan user ke dalam group docker
```bash
$ sudo usermod -aG docker nama_user
```

Yaps, sekian dulu untuk tutorial kali ini, sampai jumpa di tutorial berikutnya!

Read More

Docker : Apa itu docker ?

 

Hallo semua, karena pada kesempatan kali ini kami akan berbagai tutorial tentang Docker, kenapa perlu kami share tentang docker, karena sebelumnya kami bahasa tentang kubernetes tapi tidak di dahului dengan belajar docker, jadi kurang tepat kalau belajar Kubernetes tapi belum paham docker, karena docker ini syarat wajib sebelum masuk kubernetes.

Docker adalah sebuah aplikasi yang bersifat open source yang berfungsi sebagai wadah/container untuk mengepak/memasukkan sebuah software secara lengkap beserta semua hal lainnya yang dibutuhkan oleh software tersebut dapat berfungsi. Pengaturan software beserta file/hal pendukung lainnya akan menjadi sebuah Image (istilah yang diberikan oleh docker). Kemudian sebuah instan dari Image tersebut kemudian disebut Container. docker, Docker pada awal didirikannya pada tahun 2009 menggunakan nama dotCloud Inc. Namun, pada tahun 2013 dotCloud diubah menggunakan nama Docker. Docker ini hadir bersamaan dengan munculnya Teknologi yang dikenal dengan microservices yaitu Pembagian aplikasi menjadi bagian-bagian kecil yang saling terhubung. Dan Docker mendukung teknologi ini, karena bisa dikatakan implentasi dari microservices juga kebanyakan menggunakan docker.

Perbedaan antara docker dengan virtual machine, bisa kita lihat perbandingannya pada arsitektur berikut :

Pada gambar diatas terlihat, perbandingan keduanya, ketika kita menggunakan VM, maka kita perlu menginstall Sistem operasi lalu kita bisa install aplikasi di atas sistem operasi tersebut, sedangkan yang di docker/container kita hanya perlu menjalankan aplikasi yang kita butuhkan saja, untuk sistem operasi akan mengikuti HOST OS dari Server docker tersebut. Dari dua gambaran tersebut dapat kita pahami keuntungan menggunakan container salah satunya adalah lebih cepat, salah satunya dengan docker yang termasuk container.

Di Docker sendiri menyediakan beberapa fitur, diantaranya yaitu :

• • Docker Engine, digunakan untuk membangun Docker images dan membuat kontainer Docker.

• • Docker Hub, registry yang digunakan untuk berbagai macam Docker images

• • Docker Compose, digunakan untuk mendefinisikan aplikasi menggunakan banyak kontainer Docker.
  • Docker support untuk Mac, Linux dan Windows

Sedangkan komponen-komponen yang ada pada docker sebagai berikut :

• Docker image, merupakan file berisi informasi dan petunjuk untuk membangun container. Image juga berfungsi untuk menggunakan dan mengirimkan informasi;
• Container, adalah lingkungan untuk mengemas dan menjalankan aplikasi. Ini mencakup kode, runtime, system tools, dan pengaturan. Container hanya bisa mengakses resource yang telah ditentukan dalam docker image;
• Docker client, yaitu tempat di mana pengguna dapat mengirimkan perintah seperti docker build, docker pull, dan docker run kepada Docker daeomon;
• Docker Engine Rest API, digunakan untuk berinteraksi dengan Docker daemon. Ini bisa diakses klien melalui HTTP;
• Docker host, menyediakan lingkungan yang lengkap untuk menjalankan aplikasi. Dia bertanggung jawab terhadap penerimaan perintah yang diberikan Docker client;
• Docker daemon, yaitu proses pengelolaan Docker images, kontainer, network, dan storage volumes. Docker daemon menerima request dari Docker API dan akan memprosesnya;
• Docker registry, wadah untuk menyimpan Docker image. Docker image akan memberi reaksi sesuai perintah yang diberikan. Misalnya saat diberi perintah docker push, docker image akan didorong atau dibagikan ke registri Docker Hub;
• Docker Hub adalah layanan yang disediakan untuk menemukan dan berbagi gambar container dengan tim.

Kurang lebih begitu penjelasan tentang docker, sampai ketemu di tutorial berikutnya!

Read More

Ubuntu 18.04 : how to deploy pod on Minikube

     Hallo semua, Pada kesempatan kali ini kami akan share tentang bagaimana caranya deploy pada minikube, lebih tepatnya kita akan coba untuk membuat deployment  aplikasi pada kubernetes yang pada percobaa ini menggunakan minikube. Sebelum itu pastikan sudah install Minikube ya, jika belum bisa intip postingan install minikube . Jika sudah langsung lanjut aja ke step berikut :

```bash
# Membuat deployment dengan image nginx
root@minikube:~# kubectl create deployment test-nginx --image=nginx

deployment.apps/test-nginx created

#melihat pods yang sudah dibuat dari pembuatan deployment 
root@minikube:~# kubectl get pods

NAME                          READY   STATUS    RESTARTS   AGE
test-nginx-6dbb5ccbb6-ghxhm   1/1     Running   0          10s

# menampilkan environment variabel dari pod yang sudah dibuat
root@minikube:~# kubectl exec test-nginx-6dbb5ccbb6-ghxhm env

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=test-nginx-6dbb5ccbb6-ghxhm
KUBERNETES_PORT_443_TCP=tcp://10.96.0.1:443
KUBERNETES_PORT_443_TCP_PROTO=tcp
KUBERNETES_PORT_443_TCP_PORT=443
KUBERNETES_PORT_443_TCP_ADDR=10.96.0.1
KUBERNETES_SERVICE_HOST=10.96.0.1
KUBERNETES_SERVICE_PORT=443
KUBERNETES_SERVICE_PORT_HTTPS=443
KUBERNETES_PORT=tcp://10.96.0.1:443
NGINX_VERSION=1.15.5-1~stretch
NJS_VERSION=1.15.5.0.2.4-1~stretch
HOME=/root

# Mencoba akses ke shell dari pod
root@minikube:~# kubectl exec -it test-nginx-6dbb5ccbb6-ghxhm bash
root@test-nginx-6dbb5ccbb6-ghxhm:/# hostname

test-nginx-6dbb5ccbb6-ghxhm
root@test-nginx-6dbb5ccbb6-ghxhm:/# exit


# menampilkan logs dari pod
root@minikube:~# kubectl logs test-nginx-6dbb5ccbb6-ghxhm

127.0.0.1 - - [22/Oct/2018:04:53:47 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.52.1" "-"

# melakukan scale out pada pod
root@minikube:~# kubectl scale deployment test-nginx --replicas=3

deployment.extensions/test-nginx scaled

# check pod yang sudah di scale out
root@minikube:~# kubectl get pods

NAME                          READY   STATUS    RESTARTS   AGE
test-nginx-6dbb5ccbb6-ghxhm   1/1     Running   0          4m
test-nginx-6dbb5ccbb6-j4z2p   1/1     Running   0          11s
test-nginx-6dbb5ccbb6-n54g4   1/1     Running   0          11s

# meng expose service pod
root@minikube:~# kubectl expose deployment test-nginx --type="NodePort" --port 80

service "test-nginx" exposed

# check service yang sudah di expose
root@minikube:~# kubectl get services test-nginx

NAME         TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
test-nginx   NodePort   10.96.215.196           80:31051/TCP   10s

# perintah pada minikube untuk menampikan ip dari service
root@minikube:~# minikube service test-nginx --url

http://192.168.39.30:31051

# check service apakah berjalan
root@minikube:~# curl http://192.168.39.30:31051

# menghapus service
root@minikube:~# kubectl delete services test-nginx

service "test-nginx" deleted

# menghapus pods
root@minikube:~# kubectl delete deployment test-nginx

deployment.extensions "test-nginx" deleted 
```

Yaps, selesai sudah tutorial pada kesempatan kali ini, sampai jumpa di tutorial berikutnya!

Read More

Ubuntu 18.04 : Minikube Install

 

Hallo semua, pada kesempatan kali ini kami akan share tentang minikube , di post ini akan kami share  bagaimana cara installnya. Minikube sendiri adalah Perangkat lunak yang memungkinkan kita untuk menjalan kubernetes pada komputer lokal kita dengan single node dan cluster. Dengan minikube memungkinkan kita untuk belajar tentang kubernetes dan juga testing ataupun development pada Komputer lokal kita, karena minikube relatif lebih ringan, jika dibandingkan dengan kubernetes original. Hal yang perlu diperhatikan sebelum kita install minikube, adalah bahwa komputer kita support hypervisor untuk menjalankan minikube.  Seperti virtualbox, vmware, kvm dan lainya. Dan disini saya menggunakan kvm. Untuk installasi dan panduan menggunakan KVM ada di postingan berikut install kvm 

Berikut adalah langkah-langkah untuk installasinya : minikube

```bash
root@minikube:~# apt-get install apt-transport-https -y
root@minikube:~# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -

OK
root@minikube:~# echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" | tee -a /etc/apt/sources.list.d/kubernetes.list

root@minikube:~# apt update

root@minikube:~# apt -y install kubectl
root@minikube:~# wget https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 -O minikube

root@minikube:~# wget https://storage.googleapis.com/minikube/releases/latest/docker-machine-driver-kvm2

root@minikube:~# chmod 755 minikube docker-machine-driver-kvm2

root@minikube:~# mv minikube docker-machine-driver-kvm2 /usr/local/bin/
root@minikube:~# minikube version

minikube version: v0.30.0
root@minikube:~# kubectl version -o json

{
  "clientVersion": {
    "major": "1",
    "minor": "12",
    "gitVersion": "v1.12.1",
    "gitCommit": "4ed3216f3ec431b140b1d899130a69fc671678f4",
    "gitTreeState": "clean",
    "buildDate": "2018-10-05T16:46:06Z",
    "goVersion": "go1.10.4",
    "compiler": "gc",
    "platform": "linux/amd64"
  }
}

# Menjalankan Minikube dengan driver kvm

root@minikube:~# minikube start --vm-driver kvm2

Starting local Kubernetes v1.10.0 cluster...
Starting VM...
Downloading Minikube ISO
 170.78 MB / 170.78 MB [====================] 100.00% 0s
Getting VM IP address...
Moving files into cluster...
Downloading kubeadm v1.10.0
Downloading kubelet v1.10.0
Finished Downloading kubelet v1.10.0
Finished Downloading kubeadm v1.10.0
Setting up certs...
Connecting to cluster...
Setting up kubeconfig...
Starting cluster components...
Kubectl is now configured to use the cluster.
Loading cached images from config file.

# Menampilkan status minikube

root@minikube:~# minikube status

minikube: Running
cluster: Running
kubectl: Correctly Configured: pointing to minikube-vm at 192.168.39.30
root@minikube:~# minikube service list

|-------------|----------------------|--------------|
|  NAMESPACE  |         NAME         |     URL      |
|-------------|----------------------|--------------|
| default     | kubernetes           | No node port |
| kube-system | kube-dns             | No node port |
| kube-system | kubernetes-dashboard | No node port |
|-------------|----------------------|--------------|

root@minikube:~# minikube docker-env

export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.39.30:2376"
export DOCKER_CERT_PATH="/root/.minikube/certs"
export DOCKER_API_VERSION="1.35"
# Run this command to configure your shell:
# eval $(minikube docker-env)

root@minikube:~# kubectl cluster-info

Kubernetes master is running at https://192.168.39.30:8443
CoreDNS is running at https://192.168.39.30:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

root@minikube:~# kubectl get nodes

NAME       STATUS   ROLES    AGE   VERSION
minikube   Ready    master   1m    v1.10.0

# Menampilkan Vm yang digunakan untuk minikube

root@minikube:~# virsh list

 Id    Name                           State
----------------------------------------------------
 1     minikube                       running

# Akses ke console server/vm minikube

root@minikube:~# minikube ssh

                         _             _
            _         _ ( )           ( )
  ___ ___  (_)  ___  (_)| |/')  _   _ | |_      __
/' _ ` _ `\| |/' _ `\| || , <  ( ) ( )| '_`\  /'__`\
| ( ) ( ) || || ( ) || || |\`\ | (_) || |_) )(  ___/
(_) (_) (_)(_)(_) (_)(_)(_) (_)`\___/'(_,__/'`\____)'

$ hostname

minikube

$ exit

# Untuk menghentikan Minikube

root@minikube:~# minikube stop

Stopping local Kubernetes cluster...
Machine stopped.

# Untuk menghapus minikube

root@minikube:~# minikube delete

Deleting local Kubernetes cluster...
Machine deleted.

# check pada kvm setelah kita hapus minikube

root@minikube:~# virsh list --all

 Id    Name                           State
----------------------------------------------------

```

Yaps, selesai sudah tutorial kali ini, sampai ketemu di tutorial berikutnya !

Read More

Ubuntu 18.04 : Managament tools kvm

 

Hallo semua, pada Kesempatan kali ini, masih melanjutkan tutorial sebelumnya yaitu berhubungan dengan KVM, tapi pada Tutorial kali ini berhubungan dengan management tools pada kvm. Berikut tools-tools  yang biasa digunakan dalam mengatur  vm pada KVM.

1. Install beberapa package

```bash
root@kvm:~# apt-get install -y libguestfs-tools virt-top 
```

2. Mendapatkan OS secara official dan membuat vm

```bash
# Menampilkan template OS yang ada

root@kvm:~# virt-builder -l

.....
.....
ubuntu-10.04             x86_64     Ubuntu 10.04 (Lucid)
ubuntu-12.04             x86_64     Ubuntu 12.04 (Precise)
ubuntu-14.04             x86_64     Ubuntu 14.04 (Trusty)
ubuntu-16.04             x86_64     Ubuntu 16.04 (Xenial)
ubuntu-18.04             x86_64     Ubuntu 18.04 (bionic)
opensuse-13.1            x86_64     openSUSE 13.1
opensuse-13.2            x86_64     openSUSE 13.2
opensuse-42.1            x86_64     openSUSE Leap 42.1
opensuse-tumbleweed      x86_64     openSUSE Tumbleweed

# Membuat image dari template yang ada(contoh ubuntu-18.04

root@kvm:~# virt-builder ubuntu-18.04 --format qcow2 --size 20G -o ubuntu1804.qcow2 --root-password password

[   3.7] Downloading: http://libguestfs.org/download/builder/ubuntu-18.04.xz
[  74.0] Planning how to build this image
[  74.0] Uncompressing
.....
.....
                   Output file: ubuntu1804.qcow2
                   Output size: 20.0G
                 Output format: qcow2
            Total usable space: 19.6G
                    Free space: 18.1G (92%)

# Membuat vm dari image yang telah dibuat

root@kvm:~# virt-install \
--name ubuntu-18.04 \
--ram 4096 \
--disk path=/var/kvm/images/ubuntu1804.qcow2 \
--vcpus 2 \
--os-type linux \
--os-variant ubuntu18.04 \
--network bridge=br0 \
--graphics none \
--serial pty \
--console pty \
--boot hd \
--noreboot \
--import
```

3. Melihat direktori pada vm

```bash
root@kvm:~# virt-ls -l -d ubuntu1804 /root

total 20
drwx------  2 0 0 4096 May  7 10:22 .
drwxr-xr-x 22 0 0 4096 May  7 10:15 ..
-rw-------  1 0 0  153 May  7 11:44 .bash_history
-rw-r--r--  1 0 0  570 Jan 31  2010 .bashrc
-rw-r--r--  1 0 0  140 Nov 19  2007 .profile

```

4. membaca file yang ada pada vm

```bash
root@kvm:~# virt-cat -d ubuntu1804 /etc/passwd
```

5. mengedit file/konfigurasi yang ada pada VM

```bash
root@kvm:~# virt-edit -d ubuntu1804 /etc/fstab
```

6. Melihat pemakaian disk pada vm

```bash
root@kvm:~# virt-df -d ubuntu1804

Filesystem                           1K-blocks       Used  Available  Use%
ubuntu1804:/dev/sda1                       240972      33211     195320   14%
ubuntu1804:/dev/debian-vg/root           29284444     958140   26815700    4%
```

7. mountting disk vm ke folder host os

```bash
root@kvm:~# guestmount -d ubuntu1804 -i /mnt
root@kvm:~# ll /mnt
total 89
drwxr-xr-x  2 root root  4096 May  7 19:19 bin
drwxr-xr-x  4 root root  1024 May  7 19:20 boot
drwxr-xr-x  4 root root  4096 May  7 19:13 dev
drwxr-xr-x 83 root root  4096 May  7 19:24 etc
drwxr-xr-x  3 root root  4096 May  7 19:20 home
...
...

```

8. melihat status pada vm

```bash
root@kvm:~# virt-top
virt-top 21:58:43 - x86_64 4/4CPU 2801MHz 12158MB
3 domains, 1 active, 1 running, 0 sleeping, 0 paused, 2 inactive D:0 O:0 X:0
CPU: 0.0%  Mem: 4096 MB (4096 MB by guests)

   ID S RDRQ WRRQ RXBY TXBY %CPU %MEM    TIME   NAME
    6 R                      0.0  0.0   0:04.92 ubuntu1804
    -                                           (template)
    -                                           (win2k12R2)

```

Yaps, selesai sudah tutorial kita kali ini, sampai jumpa di tutorial berikutnya!

Read More

Cisco : Spanning Tree Protocol (STP)

 

    Hallo, Semua. Pada kesempatan kali ini kami akan sharing tutorial tentang spanning tree protocol atau biasa dikenal dengan STP. STP ini banyak digunakan dalam Jika pada switch kita menggunakan lebih dari satu atau lebih interface yang memiliki tujuan yang sama. Inti dari STP ini adalah mencegah terjadinya looping karena kondisi ini akan menyebabkan paket tidak akan pernah sampai ke tujuan. Pada contoh diatas kita memiliki 3 switch yang masing-masing terhubung dengan 1 interface tapi mengarah ke tujuan yang sama, dan berputar. jika ada frame (data yang dibawa switch) di sana, maka frame  tersebut tidak akan pernah sampai. 

    Cara kerja dari STP sendiri adalah melakukan blocking pada salah satu interface dengan begitu hanya akan digunakan satu jalur saja, dan looping  dapat diatasi. Dan port yang di block tadi akan menjadi jalur cadangan, jika jalur utama mati atau tidak berfungsi. Spanning Tree Protocol bekerja di layer 2 OSI layer. STP biasa digunakan pada switch, router yang menjalankan mode bridge, serta mulitlayer swicth yang berfungsi sebagai switch.

    Pada STP, terdapat istilah Root bridge dan non-Root bridge. Root Bridge merupakan switch yang semua portnya aktif/menyala. Sedangkan Non-Root Bridge adalah switch-switch selain Root Bridge. Jika pada kasus, kita memiliki 2 switch maka, yang menjadi non-Root Bridge adalah switch  yang salah satu portnya mati, atau blocking. Pemilihan Root Bridge ini berdasarkan pada priority. Dan yang akan menjadi Root Bridge adalah switch dengan priority terendah. Apabila nilai priority dari beberapa switch memiliki nilai yang sama, maka pemilihan Root Bridge akan dilihat dari nilai MAC Address terendah. Switch yang memiliki nilai MAC Address paling kecil akan menjadi Root Bridge. 

Pada STP juga dikenal beberapa port, seperti yang sempat kita singgung diatas. Beberapa jenis port tersebut antara lain :

• Designated Port, yaitu port yang digunakan untuk mengirim data (memiliki MAC address terkecil).
• Root Port, yaitu port pada switch yang terhubung ke Root Bridge.
• Blocking Port, yaitu port yang diblok sehingga menjadi tidak aktif dan tidak digunakan untuk mengirim data. Biasanya blocking port dipilih dari nilai MAC address terbesar, nilai port terbesar, atau port dengan bandwidth terkecil.

Berikut adalah contoh lab sederhana untuk spanning tree protokol(STP):

Topologi

Kita tidak perlu melakukan konfigurasi, karena akan otomatis, berikut akan kami tampilkan hasil dari spanning tree yang ada :

1. SW0

```python
SW0#show spanning-tree 
VLAN0001
  Spanning tree enabled protocol ieee
  Root ID    Priority    32769
             Address     0006.2A52.7436
             Cost        19
             Port        2(FastEthernet0/2)
             Hello Time  2 sec  Max Age 20 sec  Forward Delay 15 sec

  Bridge ID  Priority    32769  (priority 32768 sys-id-ext 1)
             Address     0050.0FD4.0413
             Hello Time  2 sec  Max Age 20 sec  Forward Delay 15 sec
             Aging Time  20

Interface        Role Sts Cost      Prio.Nbr Type
---------------- ---- --- --------- -------- --------------------------------
Fa0/2            Root FWD 19        128.2    P2p
Fa0/1            Desg FWD 19        128.1    P2p

SW0#
```

2. SW1

```python
SW1#show spanning-tree 
VLAN0001
  Spanning tree enabled protocol ieee
  Root ID    Priority    32769
             Address     0006.2A52.7436
             Cost        19
             Port        2(FastEthernet0/2)
             Hello Time  2 sec  Max Age 20 sec  Forward Delay 15 sec

  Bridge ID  Priority    32769  (priority 32768 sys-id-ext 1)
             Address     0060.2F14.4813
             Hello Time  2 sec  Max Age 20 sec  Forward Delay 15 sec
             Aging Time  20

Interface        Role Sts Cost      Prio.Nbr Type
---------------- ---- --- --------- -------- --------------------------------
Fa0/1            Altn BLK 19        128.1    P2p
Fa0/2            Root FWD 19        128.2    P2p

SW1#
```

3. SW3

```python
SW2#show spanning-tree 
VLAN0001
  Spanning tree enabled protocol ieee
  Root ID    Priority    32769
             Address     0006.2A52.7436
             This bridge is the root
             Hello Time  2 sec  Max Age 20 sec  Forward Delay 15 sec

  Bridge ID  Priority    32769  (priority 32768 sys-id-ext 1)
             Address     0006.2A52.7436
             Hello Time  2 sec  Max Age 20 sec  Forward Delay 15 sec
             Aging Time  20

Interface        Role Sts Cost      Prio.Nbr Type
---------------- ---- --- --------- -------- --------------------------------
Fa0/2            Desg FWD 19        128.2    P2p
Fa0/1            Desg FWD 19        128.1    P2p

SW2#
```

Dari Contoh percobaan diatas dapat kita lihat, beberapa analisa, Bahwa yang menjadi Root Bridge adalah SW2, dan selain itu menjadi non-Root Bridge. Untuk Role masing-masing port juga dapat kita lihat besama, pada SW2 yang menjadi Root Bridge kedua portnya aktif, dan pada SW0, yang menjadi jalur, kedua portnya aktif, dengan salah satu port menjadi Root port karen terhubung ke Root Bridge, Sedangkan SW1, memiliki port yang terblocking kita bisa lihat port pada SW1 ada yang bewarna orange, dan pada konfigurasi kita dapat lihat status port dari SW1 salah satu ada yang Block,  tapi menjadi Alternatif, dan juga memiliki Root port karena salah satu portnya terhubung secara langsung ke Root Bridge. 

Yaps, selasai sudah, untuk hari ini, Sampai jumpa pada Tutorial berikutnya !

Read More