Senin, 20 Desember 2021

ODOO-docker

 logo

https://hub.docker.com/_/odoo

How to use this image

This image requires a running PostgreSQL server.

Start a PostgreSQL server

$ docker run -d -e POSTGRES_USER=odoo -e POSTGRES_PASSWORD=odoo -e POSTGRES_DB=postgres --name db postgres:13

Start an Odoo instance

$ docker run -p 8069:8069 --name odoo --link db:db -t odoo

The alias of the container running Postgres must be db for Odoo to be able to connect to the Postgres server.

Stop and restart an Odoo instance

$ docker stop odoo
$ docker start -a odoo

Use named volumes to preserve data

When the Odoo container is created like described above, the odoo filestore is created inside the container. If the container is removed, the filestore is lost. The preferred way to prevent that is by using a Docker named volume.

$ docker run -v odoo-data:/var/lib/odoo -d -p 8069:8069 --name odoo --link db:db -t odoo

With the above command, the volume named odoo-data will persist even if the container is removed and can be re-used by issuing the same command.

The path /var/lib/odoo used as the mount point of the volume must match the odoo data_dir in the config file or as CLI parameters.

Note that the same principle applies to the Postgresql container and a named volume can be used to preserve the database when the container is removed. So the database container could be started like this (before the odoo container):

$ docker run -d -v odoo-db:/var/lib/postgresql/data -e POSTGRES_USER=odoo -e POSTGRES_PASSWORD=odoo -e POSTGRES_DB=postgres --name db postgres:13

Stop and restart a PostgreSQL server

When a PostgreSQL server is restarted, the Odoo instances linked to that server must be restarted as well because the server address has changed and the link is thus broken.

Restarting a PostgreSQL server does not affect the created databases.

Run Odoo with a custom configuration

The default configuration file for the server (located at /etc/odoo/odoo.conf) can be overriden at startup using volumes. Suppose you have a custom configuration at /path/to/config/odoo.conf, then

$ docker run -v /path/to/config:/etc/odoo -p 8069:8069 --name odoo --link db:db -t odoo

Please use this configuration template to write your custom configuration as we already set some arguments for running Odoo inside a Docker container.

You can also directly specify Odoo arguments inline. Those arguments must be given after the keyword -- in the command-line, as follows

$ docker run -p 8069:8069 --name odoo --link db:db -t odoo -- --db-filter=odoo_db_.*

Mount custom addons

You can mount your own Odoo addons within the Odoo container, at /mnt/extra-addons

$ docker run -v /path/to/addons:/mnt/extra-addons -p 8069:8069 --name odoo --link db:db -t odoo

Run multiple Odoo instances

$ docker run -p 8070:8069 --name odoo2 --link db:db -t odoo
$ docker run -p 8071:8069 --name odoo3 --link db:db -t odoo

Please note that for plain use of mails and reports functionalities, when the host and container ports differ (e.g. 8070 and 8069), one has to set, in Odoo, Settings->Parameters->System Parameters (requires technical features), web.base.url to the container port (e.g. 127.0.0.1:8069).

Environment Variables

Tweak these environment variables to easily connect to a postgres server:

  • HOST: The address of the postgres server. If you used a postgres container, set to the name of the container. Defaults to db.
  • PORT: The port the postgres server is listening to. Defaults to 5432.
  • USER: The postgres role with which Odoo will connect. If you used a postgres container, set to the same value as POSTGRES_USER. Defaults to odoo.
  • PASSWORD: The password of the postgres role with which Odoo will connect. If you used a postgres container, set to the same value as POSTGRES_PASSWORD. Defaults to odoo.

Docker Compose examples

The simplest docker-compose.yml file would be:

version: '3.1'
services:
  web:
    image: odoo:14.0
    depends_on:
      - db
    ports:
      - "8069:8069"
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_PASSWORD=odoo
      - POSTGRES_USER=odoo

If the default postgres credentials does not suit you, tweak the environment variables:

version: '3.1'
services:
  web:
    image: odoo:14.0
    depends_on:
      - mydb
    ports:
      - "8069:8069"
    environment:
    - HOST=mydb
    - USER=odoo
    - PASSWORD=myodoo
  mydb:
    image: postgres:13
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_PASSWORD=myodoo
      - POSTGRES_USER=odoo

Here's a last example showing you how to

  • mount custom addons located in ./addons
  • use a custom configuration file located in .config/odoo.conf
  • use named volumes for the Odoo and postgres data dir
  • use a secrets file named odoo_pg_pass that contains the postgreql password shared by both services
version: '3.1'
services:
  web:
    image: odoo:14.0
    depends_on:
      - db
    ports:
      - "8069:8069"
    volumes:
      - odoo-web-data:/var/lib/odoo
      - ./config:/etc/odoo
      - ./addons:/mnt/extra-addons
    environment:
      - PASSWORD_FILE=/run/secrets/postgresql_password
    secrets:
      - postgresql_password
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_PASSWORD_FILE=/run/secrets/postgresql_password
      - POSTGRES_USER=odoo
      - PGDATA=/var/lib/postgresql/data/pgdata
    volumes:
      - odoo-db-data:/var/lib/postgresql/data/pgdata
    secrets:
      - postgresql_password
volumes:
  odoo-web-data:
  odoo-db-data:

secrets:
  postgresql_password:
    file: odoo_pg_pass

To start your Odoo instance, go in the directory of the docker-compose.yml file you created from the previous examples and type:

docker-compose up -d

How to upgrade this image

Odoo images are updated on a regular basis to make them use recent releases (a new release of each version of Odoo is built every night). Please be aware that what follows is about upgrading from an old release to the latest one provided of the same major version, as upgrading from a major version to another is a much more complex process requiring elaborated migration scripts (see Odoo Enterprise Upgrade page or this community project which aims to write those scripts).

Suppose you created a database from an Odoo instance named old-odoo, and you want to access this database from a new Odoo instance named new-odoo, e.g. because you've just downloaded a newer Odoo image.

By default, Odoo 14.0 uses a filestore (located at /var/lib/odoo/filestore/) for attachments. You should restore this filestore in your new Odoo instance by running

$ docker run --volumes-from old-odoo -p 8070:8069 --name new-odoo --link db:db -t odoo

You can also simply prevent Odoo from using the filestore by setting the system parameter ir_attachment.location to db-storage in Settings->Parameters->System Parameters (requires technical features).

OTOMATIS RESTART-service php

 

Otomatis restart service Nginx, Apache dan MySQL Jika down

Membuat script yang bisa memonitor service Nginx atau Apache dan MySQL. Ketika salah satu service tersebut down maka script akan otomatis me-restart service tersebut agar bisa ON kembali tanpa harus melakukan secara manual.

Script ini saya ambil dari sierracircle, MIT License. Cara kerja script ini adalah

  • Memeriksa service Nginx/Apache, php-fpm dan MySQL atau lainnya, bisa diatur
  • Jika service tidak aktif, maka akan dicoba start kembali dan mengirimkan notifikasi ke email
  • Jika gagal me-restart, maka akan mengirimkan email pemberitahuan, kemudian exit

1. Buat file start_service.sh

nano start_service.sh

Isinya seperti berikut, (ganti nama servicenya nginx atau apache, juga emailnya)

#!/bin/bash

##Path, OK untuk Ubuntu 14.04 and 16.04, update 18.x
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

##set email Anda
EMAIL="email@idnetter.com"

##daftar service yang ingin dicek, sebagai contoh nginx bisa diganti apache, php-fpm atau yang lain
SERVICES=( 'nginx' 'mysql' )


for i in "${SERVICES[@]}"
do
##Cek service
`pgrep $i >/dev/null 2>&1`
STATS=$(echo $?)

##Jika service tidak aktif
if [[  $STATS == 1  ]]

then
   ##restart service
   service $i start

   ##cek restart berhasil atau gagal
   `pgrep $i >/dev/null 2>&1`
   RESTART=$(echo $?)

if [[  $RESTART == 0  ]]
##Jika restart berhasil
then

   ##hapus file di dalam /tmp jika ada
   if [ -f "/tmp/$i" ]; 
   then
      rm /tmp/$i
   fi

   ##kirim email
   MESSAGE="$i tidak aktif, tapi sudah berhasil diatasi (restart). Terjadi pada $(hostname) $(date)  "
   SUBJECT="$i tidak aktif telah berhasil direstart pada $(hostname) $(date) "
   echo $MESSAGE | mail -s "$SUBJECT" "$EMAIL"

   else
      ##Jika gagal restart

    ##cek jika ada ile di /tmp
    if [ ! -f "/tmp/$i" ]; then

     ##membuat file di /tmp (log)
     touch /tmp/$i

     ##kirim email berita buruk
     MESSAGE="$i saat ini down pada $(hostname)  at $(date)  "
     SUBJECT=" $i  down pada $(hostname) $(date) "
     echo $MESSAGE  " Script mencoba auto restart, tapi tidak berhasil, ini buruk, segera cek dan perbaiki"  | mail -s "$SUBJECT" "$EMAIL"
    fi
  fi
 fi

  done
exit 0;

2. CHMOD

chmod agar dapat dieksekusi

chmod +x start_service.sh

3. Install cron job

*/1 * * * * /root/start_service.sh

Rabu, 15 Desember 2021

STATIK ROUTE-redhat7 ok

 


https://unixhealthcheck.com/blog?id=432

How to add a new static route on RHEL 7

Any network we are trying to reach is accessed via the default gateway only, if it is not implicitly overwritten by another static route definition. Let's have a look at a routing table on a Red Hat 7 system:

# ip route show
default via 192.168.0.1 dev em1 proto static metric 100
192.168.0.0/24 dev em1 proto kernel scope link src 192.168.0.204 metric 100
192.168.1.0/24 dev em2 proto kernel scope link src 192.168.1.32
From the above we can see that any packets to reach a destination network IP 192.168.0.0/24 (meaning anything on the network 192.168.0.X with a subnet mask of 255.255.255.0) should travel via interface em1 with IP address 192.168.0.204, and any other destination network not implicitly defined should use default gateway 192.168.0.1.

Sometimes you'll require a static route. Static routes are for traffic that must not, or should not, go through the default gateway. Routing is often handled by devices on the network dedicated to routing (although any device can be configured to perform routing). Therefore, it is often not necessary to configure static routes on RHEL servers or clients. Exceptions include traffic that must pass through an encrypted VPN tunnel, or traffic that should take a specific route for reasons of cost or security or bandwidth. The default gateway is for any and all traffic which is not destined for the local network and for which no preferred route is specified in the routing table. The default gateway is traditionally a dedicated network router.

To add a new static route means to define yet another destination network as well as specify via which IP address and interface the packet should travel through in order to reach its destination. Usually this comes in handy when you have a second interface on the system that can be used to reach other networks (other than the networks that can be reached through the default gateway). In the example above that's interface em2.

For example, let's add a static route to destination network 192.168.2.0/24 via the 192.168.1.32 IP address and em2 network interface.

There are 2 ways of accomplishing this: By either using the "ip route add" command, which will define the route, but it will be lost upon reboot. Or by creating a route configuration file in the /etc/sysconfig/network-scripts/ directory.

First, the "ip route add" command:

To add a static route to a network, in other words, representing a range of IP addresses, issue this command as root:
# ip route add 192.168.2.0/24 via 192.168.1.32 dev em2
Where 192.168.2.0 is the IP address of the destination network in dotted decimal notation and /24 is the network prefix, which is equal to a subnet mask of 255.255.255.0. The network prefix is the number of enabled bits in the subnet mask. If you now rerun the "ip route show" command, you'll see that the route has been added.
192.168.2.0/24 via 192.168.1.32 dev em2 proto static metric 1
If you ever need to delete the route, you can use the same command, but just replace "add" with "delete".

Static route configuration can be stored per-interface in a /etc/syconfig/network-scripts/route-interface file. For example, fstatic routes for the em2 interface would be stored in the /etc/sysconfig/network-scripts/route-em2 file, for example:
# cat /etc/sysconfig/network-scripts/route-em2
192.168.2.0/24 via 192.168.1.32 dev em2
Once done, restart your network service (or restart the server):
# systemctl restart network

Selasa, 14 Desember 2021

ROUTE STATIK-redhat

 

How to Permanently add Static Route in Linux

permanently add static route in linux

Static routing is the process of manually entering the routes to the routing table to reach a particular destination. Basically two commands are used in Linux to add routes. The first command is the old traditional route add and second is the IP route command.

Earlier we learned how to route add in Linux, in this tutorial, here I will show you how to add permanent static routes in Linux distributions such as Centos and Ubuntu.

Adding temporary static routes

In order to add a static route temporarily on your Linux machine, you can use either route or ip command.

You can list the current routing table as follows.

$ route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         192.168.206.1   0.0.0.0         UG    100    0        0 eno1
169.254.0.0     0.0.0.0         255.255.0.0     U     1000   0        0 eno1
172.17.0.0      0.0.0.0         255.255.0.0     U     0      0        0 docker0
192.168.206.0   0.0.0.0         255.255.255.0   U     100    0        0 eno1
route -n command
route -n command

If you want to add a route to the network 198.161.1.0 through gateway 192.168.206.1, you can execute the following command.

$ sudo route add -net 198.161.1.0 netmask 255.255.255.0 gw 192.168.206.1 eno1

Alternatively, you can use ip command as follows:

$ sudo ip route add 198.161.1.0/24 via 198.168.206.1 dev eno1

Adding permanent static routes

In the above section, we saw how to add routes in Linux. But the system will forget those routes on next reboot.

1.6M
162
'It Takes Two' Is Named Game of the Year at 2021 Game Awards

So we have to add routes to config file to make it persistent.

On RHEL or CentOS, you need to modify the interface file in '/etc/sysconfig/network-scripts'.

For example, here, we have to add routes on network interface ens192. Hence, the file we need to modify will be '/etc/sysconfig/network-scripts/route-ens192'.

The basic syntax of static route in this file is:

<target-address> via <gateway-address> dev <interface>

Where,

target-address - Destination network address.

gateway-address - Router address to reach the destination address.

dev - Indicates which interface to reach the destination, interface naming schemes are eno[1-N], ens[1-N], and or eth[0-N].

So, in order to add the above route in 'route-ens192' file, append the following line.

'10.9.8.0/24 via 10.9.8.100 dev ens192'

Then, you need to restart the network service.

$ sudo service network restart

Finally, verify that the new routes are visible in the routing table using the following command.

$ route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         10.9.8.100      0.0.0.0         UG    100    0        0 ens192
10.0.0.0        0.0.0.0         255.0.0.0       U     100    0        0 ens192
10.9.8.0        10.9.8.100      255.255.255.0   UG    100    0        0 ens192

On Ubuntu Linux, if you want to add a permanent static route to your system, you have to add route entry to the '/etc/network/interfaces'. Using your favorite editor (nano, vim,...) to open the network interface file and insert the following lines to it.

'up route add -net 10.9.7.0/24 gw 10.9.8.100 dev ens160'. For example:

source /etc/network/interfaces.d/*
# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto ens160
iface ens160 inet static
address 10.9.8.41
netmask 255.255.255.0
gateway 10.9.8.100
up route add -net 10.9.7.0/24 gw 10.9.8.100 dev ens160

In order to make the change take effect, you need to restart the networking service by running:

$ sudo /etc/init.d/networking restart

Verify that the route has been configured correctly:

$ route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         10.9.8.100      0.0.0.0         UG    0      0        0 ens160
10.9.7.0        10.9.8.100      255.255.255.0   UG    0      0        0 ens160
10.9.8.0        0.0.0.0         255.255.255.0   U     0      0        0 ens160
10.233.70.0     10.9.8.45       255.255.255.0   UG    0      0        0 tunl0
10.233.90.0     0.0.0.0         255.255.255.0   U     0      0        0 *

From Ubuntu 18.04 LTS and higher version, the operating system uses the netplan YAML files for network configuration - it is located in the '/etc/netplan' directory. For example:

$ ls /etc/netplan
01-network-manager-all.yaml

In order to add persistent static route, you have to add the following lines to the netplan configuration file '/etc/netplan/01-network-manager-all.yaml'

routes:
- to: 192.168.205.0/24
  via: 192.168.206.1

For example:

# Let NetworkManager manage all devices on this system
network:
  version: 2
  renderer: NetworkManager
  ethernets:
    eno1: 
      dhcp4: true
      routes:
      - to: 192.168.205.0/24
        via: 192.168.206.1

Apply the change by running:

$ sudo netplan apply

You can verify the route configuration by running command route -n or ip route. Here is the result:

netplan ip route
The result after apply a new static route

Conclusion

In this tutorial, we learned how to add a permanent route by adding to respective config files in Linux. Thanks for reading and please leave your suggestion in the below comment section.