ಡಾಕರ್ ಸಂಯೋಜನೆ: ಮೇಕ್‌ಫೈಲ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಕೆಲಸವನ್ನು ಸರಳಗೊಳಿಸುವುದು

ಪ್ರತಿ ಕೆಲವು ವರ್ಷಗಳಿಗೊಮ್ಮೆ, ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಉದ್ಯಮವು ಒಂದು ಮಾದರಿ ಬದಲಾವಣೆಗೆ ಒಳಗಾಗುತ್ತದೆ. ಈ ವಿದ್ಯಮಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ಸೂಕ್ಷ್ಮ ಸೇವೆಗಳ ಪರಿಕಲ್ಪನೆಯಲ್ಲಿ ಬೆಳೆಯುತ್ತಿರುವ ಆಸಕ್ತಿ ಎಂದು ಗುರುತಿಸಬಹುದು. ಮೈಕ್ರೊ ಸರ್ವಿಸ್‌ಗಳು ಹೊಸ ತಂತ್ರಜ್ಞಾನವಲ್ಲವಾದರೂ, ಇತ್ತೀಚೆಗೆ ಅದರ ಜನಪ್ರಿಯತೆಯು ಅಕ್ಷರಶಃ ಗಗನಕ್ಕೇರಿದೆ.

ದೊಡ್ಡ ಏಕಶಿಲೆಯ ಸೇವೆಗಳನ್ನು ಈಗ ಸ್ವತಂತ್ರ, ಸ್ವಾಯತ್ತ ಸೂಕ್ಷ್ಮ ಸೇವೆಗಳಿಂದ ಬದಲಾಯಿಸಲಾಗುತ್ತಿದೆ. ಮೈಕ್ರೊ ಸರ್ವಿಸ್ ಅನ್ನು ಒಂದೇ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಉದ್ದೇಶಕ್ಕಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಎಂದು ಪರಿಗಣಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಇದು ಸಂಬಂಧಿತ DBMS, ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಅಪ್ಲಿಕೇಶನ್, ಸೋಲ್ರ್ ಸೇವೆಯಾಗಿರಬಹುದು.

ಈ ದಿನಗಳಲ್ಲಿ, ಮೈಕ್ರೊ ಸರ್ವೀಸ್‌ಗಳನ್ನು ಬಳಸದೆಯೇ ಹೊಸ ಸಾಫ್ಟ್‌ವೇರ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದನ್ನು ಕಲ್ಪಿಸುವುದು ಕಷ್ಟ. ಮತ್ತು ಈ ಪರಿಸ್ಥಿತಿಯು ನಮ್ಮನ್ನು ಡಾಕರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗೆ ಕರೆದೊಯ್ಯುತ್ತದೆ.

ಡಾಕರ್

ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಡಾಕರ್, ಮೈಕ್ರೋ ಸರ್ವಿಸ್‌ಗಳ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ನಿಯೋಜನೆಯಲ್ಲಿ, ಬಹುತೇಕ ಉದ್ಯಮದ ಮಾನದಂಡವಾಗಿದೆ. ಪ್ರಾಜೆಕ್ಟ್ ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ನೀವು ಡಾಕರ್ ಮಾತ್ರ ಸ್ವತಂತ್ರ ಕಂಟೈನರೈಸೇಶನ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಆಗಿದ್ದು ಅದು ಸಂಸ್ಥೆಗಳಿಗೆ ಯಾವುದೇ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಲೀಸಾಗಿ ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಹಾಗೆಯೇ ಅವುಗಳನ್ನು ಯಾವುದೇ ಪರಿಸರದಲ್ಲಿ ವಿತರಿಸಲು ಮತ್ತು ಚಲಾಯಿಸಲು - ಹೈಬ್ರಿಡ್ ಮೋಡಗಳಿಂದ ಅಂಚಿನ ವ್ಯವಸ್ಥೆಗಳವರೆಗೆ.

ಡಾಕರ್ ಕಂಪೋಸ್

ತಂತ್ರಜ್ಞಾನ ಡಾಕರ್ ಕಂಪೋಸ್ ಬಹು-ಧಾರಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಡಾಕರ್ ಕಂಪೋಸ್ ಯೋಜನೆಯು ಪ್ರಾಜೆಕ್ಟ್‌ನ ರಚನೆಕಾರರಿಗೆ ಅಗತ್ಯವಿರುವಷ್ಟು ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.

ಡಾಕರ್ ಕಂಪೋಸ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಅಪ್ಲಿಕೇಶನ್ ಸೇವೆಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಮತ್ತು ಅವುಗಳ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಸಂಘಟಿಸಲು YAML ಫೈಲ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಡಾಕರ್ ಕಂಪೋಸ್ ಬಹು-ಧಾರಕ ಡಾಕರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ವಿವರಿಸುವ ಮತ್ತು ಚಾಲನೆ ಮಾಡುವ ಸಾಧನವಾಗಿದೆ.

ಹೋಸ್ಟ್ ಸಿಸ್ಟಂನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಎರಡು ಕಂಟೇನರ್ಗಳು

ಗ್ನು ಮೇಕ್

ಪ್ರೋಗ್ರಾಂ make, ಮೂಲಭೂತವಾಗಿ ಮೂಲ ಕೋಡ್‌ನಿಂದ ಪ್ರೋಗ್ರಾಂಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳ ಕಟ್ಟಡವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ಸಾಧನವಾಗಿದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು ಅದನ್ನು ಹೇಳಬಹುದು make ಕೆಲವು ಇನ್‌ಪುಟ್ ವಸ್ತುಗಳನ್ನು ಕೆಲವು ಔಟ್‌ಪುಟ್ ರೂಪಕ್ಕೆ, ಕೆಲವು ಗುರಿಗೆ ಪರಿವರ್ತಿಸಲು ಅನಿಯಂತ್ರಿತ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುವ ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆಗೆ ಅನ್ವಯಿಸುತ್ತದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಆಜ್ಞೆಗಳು docker-compose ಅಮೂರ್ತ ಗುರಿಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುವುದು (ಫೋನ್ ಗುರಿಗಳು).

ಕಾರ್ಯಕ್ರಮವನ್ನು ಹೇಳಲು make ಅದರಿಂದ ನಮಗೆ ಬೇಕಾದುದನ್ನು ಕುರಿತು, ನಮಗೆ ಫೈಲ್ ಅಗತ್ಯವಿದೆ Makefile.

ನಮ್ಮಲ್ಲಿ Makefile ನಿಯಮಿತ ಆಜ್ಞೆಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ docker и docker-compose, ಇದು ಅನೇಕ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಅವುಗಳೆಂದರೆ, ನಾವು ಕಂಟೇನರ್ ಅನ್ನು ಜೋಡಿಸುವುದು, ಅದನ್ನು ಪ್ರಾರಂಭಿಸುವುದು, ನಿಲ್ಲಿಸುವುದು, ಮರುಪ್ರಾರಂಭಿಸುವುದು, ಕಂಟೇನರ್‌ಗೆ ಬಳಕೆದಾರರ ಲಾಗಿನ್ ಅನ್ನು ಸಂಘಟಿಸುವ ಬಗ್ಗೆ, ಕಂಟೇನರ್ ಲಾಗ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಬಗ್ಗೆ ಮತ್ತು ಇತರ ರೀತಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ.

ಡಾಕರ್ ಸಂಯೋಜನೆಗಾಗಿ ವಿಶಿಷ್ಟ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಕೆಳಗಿನ ಘಟಕಗಳನ್ನು ಹೊಂದಿರುವ ಸಾಮಾನ್ಯ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಊಹಿಸೋಣ:

• ಟೈಮ್‌ಸ್ಕೇಲ್‌ಡಿಬಿ ಡೇಟಾಬೇಸ್ (ಪೋಸ್ಟ್‌ಗ್ರೆಸ್).
• Express.js ಅಪ್ಲಿಕೇಶನ್.
• ಪಿಂಗ್ (ಕೇವಲ ಕಂಟೇನರ್, ವಿಶೇಷ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ).

ಈ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ 3 ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳು ಮತ್ತು ಫೈಲ್ ಅಗತ್ಯವಿದೆ docker-compose, ಇದು ಈ ಕಂಟೇನರ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸೂಚನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಪ್ರತಿಯೊಂದು ಕಂಟೇನರ್ ವಿಭಿನ್ನ ಸ್ಪರ್ಶ ಬಿಂದುಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಕಂಟೇನರ್ನೊಂದಿಗೆ timescale ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ರೀತಿಯಲ್ಲಿಯೇ ಕೆಲಸ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಅವುಗಳೆಂದರೆ, ಈ ಕೆಳಗಿನ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ:

• ಪೋಸ್ಟ್‌ಗ್ರೆಸ್ ಶೆಲ್‌ಗೆ ಲಾಗ್ ಇನ್ ಆಗುತ್ತಿದೆ.
• ಕೋಷ್ಟಕಗಳ ಆಮದು ಮತ್ತು ರಫ್ತು.
• ಸೃಷ್ಟಿ pg_dump ಕೋಷ್ಟಕಗಳು ಅಥವಾ ಡೇಟಾಬೇಸ್ಗಳು.

Express.js ಅಪ್ಲಿಕೇಶನ್ ಕಂಟೇನರ್, expressjs, ಈ ಕೆಳಗಿನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೊಂದಿರಬಹುದು:

• ಸಿಸ್ಟಮ್ ಲಾಗ್‌ನಿಂದ ತಾಜಾ ಡೇಟಾವನ್ನು ಒದಗಿಸುವುದು.
• ಕೆಲವು ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಶೆಲ್‌ಗೆ ಲಾಗಿನ್ ಮಾಡಿ.

ಧಾರಕಗಳೊಂದಿಗೆ ಸಂವಹನ

ಒಮ್ಮೆ ನಾವು ಡಾಕರ್ ಕಂಪೋಸ್ ಬಳಸಿ ಕಂಟೈನರ್‌ಗಳ ನಡುವೆ ಸಂವಹನವನ್ನು ಹೊಂದಿಸಿದರೆ, ಆ ಕಂಟೇನರ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಇದು ಸಮಯವಾಗಿದೆ. ಡಾಕರ್ ಕಂಪೋಸ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಒಂದು ಕಮಾಂಡ್ ಇರುತ್ತದೆ docker-compose, ಪೋಷಕ ಆಯ್ಕೆ -f, ಇದು ಫೈಲ್ ಅನ್ನು ಸಿಸ್ಟಮ್ಗೆ ವರ್ಗಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ docker-compose.yml.

ಈ ಆಯ್ಕೆಯ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಫೈಲ್‌ನಲ್ಲಿ ನಮೂದಿಸಲಾದ ಕಂಟೇನರ್‌ಗಳಿಗೆ ಮಾತ್ರ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಂವಹನವನ್ನು ಮಿತಿಗೊಳಿಸಬಹುದು docker-compose.yml.

ಕಮಾಂಡ್‌ಗಳನ್ನು ಬಳಸುವಾಗ ಕಂಟೈನರ್‌ಗಳೊಂದಿಗಿನ ಸಂವಹನಗಳು ಹೇಗಿರುತ್ತವೆ ಎಂಬುದನ್ನು ನೋಡೋಣ docker-compose. ನಾವು ಶೆಲ್‌ಗೆ ಲಾಗ್ ಇನ್ ಮಾಡಬೇಕಾಗಿದೆ ಎಂದು ನಾವು ಊಹಿಸಿದರೆ psql, ನಂತರ ಅನುಗುಣವಾದ ಆಜ್ಞೆಗಳು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

docker-compose -f docker-compose.yml exec timescale psql -Upostgres

ಅದೇ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಳಸಲಾಗುವುದಿಲ್ಲ docker-composeಮತ್ತು docker, ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

docker exec -it  edp_timescale_1 psql -Upostgres

ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ ಆಜ್ಞೆಯನ್ನು ಬಳಸುವುದು ಯಾವಾಗಲೂ ಯೋಗ್ಯವಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ docker, ಮತ್ತು ಆಜ್ಞೆ docker-compose, ಇದು ಕಂಟೇನರ್ ಹೆಸರುಗಳನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ.

ಮೇಲಿನ ಎರಡೂ ಆಜ್ಞೆಗಳು ಕಷ್ಟವಲ್ಲ. ಆದರೆ ನಾವು ರೂಪದಲ್ಲಿ "ಹೊದಿಕೆ" ಅನ್ನು ಬಳಸಿದರೆ Makefile, ಇದು ನಮಗೆ ಸರಳ ಆಜ್ಞೆಗಳ ರೂಪದಲ್ಲಿ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಅದೇ ರೀತಿಯ ದೀರ್ಘ ಆಜ್ಞೆಗಳನ್ನು ಕರೆಯುತ್ತದೆ, ನಂತರ ಅದೇ ಫಲಿತಾಂಶಗಳನ್ನು ಈ ರೀತಿ ಸಾಧಿಸಬಹುದು:

make db-shell

ಬಳಕೆಯಾಗಿರುವುದು ಸ್ಪಷ್ಟವಾಗಿದೆ Makefile ಕಂಟೇನರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಹೆಚ್ಚು ಸುಲಭವಾಗುತ್ತದೆ!

ಕೆಲಸದ ಉದಾಹರಣೆ

ಮೇಲಿನ ಯೋಜನೆಯ ರೇಖಾಚಿತ್ರವನ್ನು ಆಧರಿಸಿ, ನಾವು ಈ ಕೆಳಗಿನ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ docker-compose.yml:

version: '3.3'
services:
    api:
        build: .
        image: mywebimage:0.0.1
        ports:
            - 8080:8080
        volumes:
            - /app/node_modules/
        depends_on:
            - timescale
        command: npm run dev
        networks:
            - webappnetwork
    timescale:
        image: timescale/timescaledb-postgis:latest-pg11
        environment:
          - POSTGRES_USER=postgres
          - POSTGRES_PASSWORD=postgres
        command: ["postgres", "-c", "log_statement=all", "-c", "log_destination=stderr"]
        volumes:
          - ./create_schema.sql:/docker-entrypoint-initdb.d/create_schema.sql
        networks:
           - webappnetwork
    ping:
       image: willfarrell/ping
       environment:
           HOSTNAME: "localhost"
           TIMEOUT: 300
networks:
   webappnetwork:
       driver: bridge

ಡಾಕರ್ ಕಂಪೋಸ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಅದು ವಿವರಿಸುವ ಕಂಟೈನರ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು, ನಾವು ಈ ಕೆಳಗಿನ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ Makefile:

THIS_FILE := $(lastword $(MAKEFILE_LIST))
.PHONY: help build up start down destroy stop restart logs logs-api ps login-timescale login-api db-shell
help:
        make -pRrq  -f $(THIS_FILE) : 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | sort | egrep -v -e '^[^[:alnum:]]' -e '^$@$$'
build:
        docker-compose -f docker-compose.yml build $(c)
up:
        docker-compose -f docker-compose.yml up -d $(c)
start:
        docker-compose -f docker-compose.yml start $(c)
down:
        docker-compose -f docker-compose.yml down $(c)
destroy:
        docker-compose -f docker-compose.yml down -v $(c)
stop:
        docker-compose -f docker-compose.yml stop $(c)
restart:
        docker-compose -f docker-compose.yml stop $(c)
        docker-compose -f docker-compose.yml up -d $(c)
logs:
        docker-compose -f docker-compose.yml logs --tail=100 -f $(c)
logs-api:
        docker-compose -f docker-compose.yml logs --tail=100 -f api
ps:
        docker-compose -f docker-compose.yml ps
login-timescale:
        docker-compose -f docker-compose.yml exec timescale /bin/bash
login-api:
        docker-compose -f docker-compose.yml exec api /bin/bash
db-shell:
        docker-compose -f docker-compose.yml exec timescale psql -Upostgres

ಇಲ್ಲಿ ವಿವರಿಸಿದ ಹೆಚ್ಚಿನ ಆಜ್ಞೆಗಳು ಎಲ್ಲಾ ಕಂಟೈನರ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸುತ್ತವೆ, ಆದರೆ ಆಯ್ಕೆಯನ್ನು ಬಳಸುತ್ತವೆ c= ಆಜ್ಞೆಯ ವ್ಯಾಪ್ತಿಯನ್ನು ಒಂದು ಕಂಟೇನರ್‌ಗೆ ಸೀಮಿತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ನಂತರ Makefile ಸಿದ್ಧ, ನೀವು ಇದನ್ನು ಈ ರೀತಿ ಬಳಸಬಹುದು:

• make help — ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಆಜ್ಞೆಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡುವುದು make.

ಲಭ್ಯವಿರುವ ಆಜ್ಞೆಗಳಲ್ಲಿ ಸಹಾಯ

• make build - ಒಂದು ಚಿತ್ರವನ್ನು ಜೋಡಿಸುವುದು Dockerfile. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಚಿತ್ರಗಳನ್ನು ಬಳಸಿದ್ದೇವೆ timescale и ping. ಆದರೆ ಚಿತ್ರ api ನಾವು ಸ್ಥಳೀಯವಾಗಿ ಸಂಗ್ರಹಿಸಲು ಬಯಸುತ್ತೇವೆ. ಈ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ ಇದನ್ನು ನಿಖರವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ.

ಡಾಕರ್ ಕಂಟೇನರ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು

• make start - ಎಲ್ಲಾ ಧಾರಕಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವುದು. ಕೇವಲ ಒಂದು ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು make start c=timescale.

ಟೈಮ್‌ಸ್ಕೇಲ್ ಕಂಟೇನರ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಲಾಗುತ್ತಿದೆ

ಪಿಂಗ್ ಕಂಟೇನರ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಲಾಗುತ್ತಿದೆ

• make login-timescale - ಕಂಟೇನರ್‌ನ ಬ್ಯಾಷ್ ಸೆಷನ್‌ಗೆ ಲಾಗಿನ್ ಮಾಡಿ timescale.

ಟೈಮ್‌ಸ್ಕೇಲ್ ಕಂಟೈನರ್‌ನಲ್ಲಿ ಬ್ಯಾಷ್ ರನ್ನಿಂಗ್

• make db-shell - ಪ್ರವೇಶ psql ಒಂದು ಪಾತ್ರೆಯಲ್ಲಿ timescale ಡೇಟಾಬೇಸ್ ವಿರುದ್ಧ SQL ಪ್ರಶ್ನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು.

ಟೈಮ್‌ಸ್ಕೇಲ್ಡ್‌ಬಿ ಕಂಟೈನರ್‌ನಲ್ಲಿ psql ರನ್ ಆಗುತ್ತಿದೆ

• make stop - ಧಾರಕಗಳನ್ನು ನಿಲ್ಲಿಸುವುದು.

ಟೈಮ್‌ಸ್ಕೇಲ್ ಕಂಟೇನರ್ ಅನ್ನು ನಿಲ್ಲಿಸುವುದು

• make down - ಧಾರಕಗಳನ್ನು ನಿಲ್ಲಿಸುವುದು ಮತ್ತು ತೆಗೆದುಹಾಕುವುದು. ನಿರ್ದಿಷ್ಟ ಧಾರಕವನ್ನು ತೆಗೆದುಹಾಕಲು, ನೀವು ಬಯಸಿದ ಧಾರಕವನ್ನು ಸೂಚಿಸುವ ಈ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ - make down c=timescale ಅಥವಾ make down c=api.

ಎಲ್ಲಾ ಕಂಟೇನರ್‌ಗಳನ್ನು ನಿಲ್ಲಿಸುವುದು ಮತ್ತು ಅಳಿಸುವುದು

ಫಲಿತಾಂಶಗಳು

ಕಂಟೈನರ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಡಾಕರ್ ಕಂಪೋಸ್ ನಮಗೆ ಹೇರಳವಾದ ಆಜ್ಞೆಗಳನ್ನು ನೀಡುತ್ತದೆಯಾದರೂ, ಕೆಲವೊಮ್ಮೆ ಈ ಆಜ್ಞೆಗಳು ದೀರ್ಘ ಮತ್ತು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಕಷ್ಟವಾಗಬಹುದು.

ಬಳಕೆಯ ವಿಧಾನ Makefile ಫೈಲ್‌ನಿಂದ ಕಂಟೈನರ್‌ಗಳೊಂದಿಗೆ ತ್ವರಿತ ಮತ್ತು ಸುಲಭವಾದ ಸಂವಹನವನ್ನು ಸ್ಥಾಪಿಸಲು ನಮಗೆ ಸಹಾಯ ಮಾಡಿದೆ docker-compose.yml. ಅವುಗಳೆಂದರೆ, ನಾವು ಈ ಕೆಳಗಿನವುಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ:

• ಡೆವಲಪರ್ ವಿವರಿಸಿದ ಪ್ರಾಜೆಕ್ಟ್ ಕಂಟೈನರ್‌ಗಳೊಂದಿಗೆ ಮಾತ್ರ ಸಂವಹನ ನಡೆಸುತ್ತಾರೆ docker-compose.yml, ಇತರ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಂಟೇನರ್‌ಗಳಿಂದ ಕೆಲಸವು ಮಧ್ಯಪ್ರವೇಶಿಸುವುದಿಲ್ಲ.
• ಒಂದು ನಿರ್ದಿಷ್ಟ ಆಜ್ಞೆಯನ್ನು ಮರೆತುಹೋದ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು make help ಮತ್ತು ಲಭ್ಯವಿರುವ ಆಜ್ಞೆಗಳಲ್ಲಿ ಸಹಾಯ ಪಡೆಯಿರಿ.
• ಇತ್ತೀಚಿನ ಲಾಗ್ ನಮೂದುಗಳನ್ನು ಪಡೆಯುವುದು ಅಥವಾ ಸಿಸ್ಟಮ್‌ಗೆ ಲಾಗ್ ಇನ್ ಮಾಡುವಂತಹ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನೀವು ದೀರ್ಘವಾದ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಪಟ್ಟಿಗಳನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಒಂದು ರೀತಿಯ ಆಜ್ಞೆ docker-compose -f docker-compose.yml exec timescale psql -Upostgres ಬದಲಾಗುತ್ತದೆ make db-shell.
• ಕಡತ Makefile ಯೋಜನೆಯು ಬೆಳೆದಂತೆ ನೀವು ಅದಕ್ಕೆ ಹೊಂದಿಕೊಳ್ಳಬಹುದು. ಉದಾಹರಣೆಗೆ, ಡೇಟಾಬೇಸ್ ಬ್ಯಾಕಪ್ ರಚಿಸಲು ಅಥವಾ ಯಾವುದೇ ಇತರ ಕ್ರಿಯೆಯನ್ನು ಮಾಡಲು ಆಜ್ಞೆಯನ್ನು ಸೇರಿಸುವುದು ಸುಲಭ.
• ಡೆವಲಪರ್‌ಗಳ ದೊಡ್ಡ ತಂಡವು ಅದೇ ಬಳಸಿದರೆ Makefile, ಇದು ಸಹಯೋಗವನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ದೋಷಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಪಿಎಸ್ ನಮ್ಮಲ್ಲಿ ಮಾರುಕಟ್ಟೆ ಒಂದು ಚಿತ್ರವಿದೆ ಡಾಕರ್, ಇದನ್ನು ಒಂದೇ ಕ್ಲಿಕ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಬಹುದು. ನೀವು ಧಾರಕಗಳ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು VPS. ಎಲ್ಲಾ ಹೊಸ ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ 3 ದಿನಗಳ ಪರೀಕ್ಷೆಯನ್ನು ಉಚಿತವಾಗಿ ನೀಡಲಾಗುತ್ತದೆ.

ಆತ್ಮೀಯ ಓದುಗರು! ಡಾಕರ್ ಕಂಪೋಸ್ ಅನ್ನು ನೀವು ಹೇಗೆ ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತೀರಿ?

ಮೂಲ: www.habr.com