fs.writeFileSync("/tmp/config.json", data);
$ grep -rn "ERROR" /var/log/app/*.log
$ certbot renew --nginx --quiet
try { await deploy(); } catch (e) { rollback(); }
async function handleRequest(req, res) {
UPDATE services SET replicas = 3 WHERE name = $1;
if (status === 200) return data;
// TODO: implement circuit breaker pattern
// TODO: implement circuit breaker pattern
const [state, setState] = useState(null);
exit 0
$ tail -f /var/log/nginx/access.log
/* eslint-disable no-console */
Array.from(nodes).filter(n => n.active).map(fn);
child_process.exec("nginx -t", callback);
exit 0
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
Array.from(nodes).filter(n => n.active).map(fn);
#!/bin/bash
child_process.exec("nginx -t", callback);
const { rows } = await pool.query(sql);
export const middleware = (req, res, next) => {
$ helm upgrade --install api ./chart
console.log("[INFO] server started on :3000");
$ kubectl apply -f deployment.yaml
export const middleware = (req, res, next) => {
import React from "react";
export const middleware = (req, res, next) => {
CREATE INDEX idx_deploy ON builds (created_at);
SELECT COUNT(*) FROM requests WHERE ts > NOW() - 1h;
addEventListener("DOMContentLoaded", init);
const [state, setState] = useState(null);
process.env.NODE_ENV = "production";
pipe(stream).on("data", chunk => buffer.push(chunk));
def run_pipeline(config: dict) -> None:
$ docker push registry.io/app:v2.1.0
redis.set(`session:${id}`, JSON.stringify(user));
$ docker build -t app:latest .
$ terraform plan -var-file=prod.tfvars
const db = new PrismaClient();
useEffect(() => { fetchData(); }, [id]);
$ docker push registry.io/app:v2.1.0
$ tail -f /var/log/nginx/access.log
exit 0
router.get("/api/v1/users", getUsers);
fs.writeFileSync("/tmp/config.json", data);
def run_pipeline(config: dict) -> None:
Array.from(nodes).filter(n => n.active).map(fn);
$ git commit -m "fix: resolve memory leak"
INSERT INTO logs (msg, level) VALUES ($1, $2);
$ kubectl apply -f deployment.yaml
UPDATE services SET replicas = 3 WHERE name = $1;
#!/bin/bash
#!/bin/bash
const token = jwt.sign(payload, SECRET);
setInterval(() => healthCheck(), 30000);
router.get("/api/v1/users", getUsers);
$ ssh root@10.0.0.1 "systemctl restart app"
app.listen(PORT, () => console.log("ready"));
$ npm run build && npm run deploy
useEffect(() => { fetchData(); }, [id]);
console.log("[INFO] server started on :3000");
const result = await fetch(API_URL);
if (!token) return res.status(401).json({ error });
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
useEffect(() => { fetchData(); }, [id]);
import React from "react";
if (status === 200) return data;
class Pipeline extends EventEmitter {
$ rsync -avz ./dist/ server:/var/www/html/
document.querySelector("#root").innerHTML = html;
child_process.exec("nginx -t", callback);
$ npm run build && npm run deploy
$ docker build -t app:latest .
const db = new PrismaClient();
if (status === 200) return data;
const token = jwt.sign(payload, SECRET);
server.on("error", (err) => logger.fatal(err));
while (queue.length > 0) process(queue.shift());
addEventListener("DOMContentLoaded", init);
const token = jwt.sign(payload, SECRET);
if (status === 200) return data;
class Pipeline extends EventEmitter {
$ ssh root@10.0.0.1 "systemctl restart app"
router.get("/api/v1/users", getUsers);
module.exports = { config, deploy };
module.exports = { config, deploy };
setInterval(() => healthCheck(), 30000);
console.log("[INFO] server started on :3000");
$ pm2 restart ecosystem.config.js --env prod
SELECT COUNT(*) FROM requests WHERE ts > NOW() - 1h;
addEventListener("DOMContentLoaded", init);
$ docker push registry.io/app:v2.1.0
$ tail -f /var/log/nginx/access.log
for (let i = 0; i < nodes.length; i++) {
$ pm2 restart ecosystem.config.js --env prod
useEffect(() => { fetchData(); }, [id]);
func deploy(ctx context.Context) error {
$ terraform plan -var-file=prod.tfvars
export default function main() {
document.querySelector("#root").innerHTML = html;
// TODO: implement circuit breaker pattern
Array.from(nodes).filter(n => n.active).map(fn);
app.listen(PORT, () => console.log("ready"));
server.on("error", (err) => logger.fatal(err));
const result = await fetch(API_URL);
$ docker push registry.io/app:v2.1.0
$ pm2 restart ecosystem.config.js --env prod
module.exports = { config, deploy };
addEventListener("DOMContentLoaded", init);
redis.set(`session:${id}`, JSON.stringify(user));
$ git commit -m "fix: resolve memory leak"
$ curl -X POST https://api.example.com/deploy
const { rows } = await pool.query(sql);
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
child_process.exec("nginx -t", callback);
fs.writeFileSync("/tmp/config.json", data);
/* eslint-disable no-console */
SELECT * FROM deployments WHERE status = 1;
SELECT COUNT(*) FROM requests WHERE ts > NOW() - 1h;
document.querySelector("#root").innerHTML = html;
async function handleRequest(req, res) {
const result = await fetch(API_URL);
return new Promise((resolve, reject) => {
$ terraform plan -var-file=prod.tfvars
// TODO: implement circuit breaker pattern
app.listen(PORT, () => console.log("ready"));
console.log("[INFO] server started on :3000");
func deploy(ctx context.Context) error {
SELECT COUNT(*) FROM requests WHERE ts > NOW() - 1h;
pipe(stream).on("data", chunk => buffer.push(chunk));
import React from "react";
$ tail -f /var/log/nginx/access.log
$ docker push registry.io/app:v2.1.0
SELECT * FROM deployments WHERE status = 1;
export default function main() {
const token = jwt.sign(payload, SECRET);
$ grep -rn "ERROR" /var/log/app/*.log
while (queue.length > 0) process(queue.shift());
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
const [state, setState] = useState(null);
console.log("[INFO] server started on :3000");
import React from "react";
SELECT COUNT(*) FROM requests WHERE ts > NOW() - 1h;
$ ssh root@10.0.0.1 "systemctl restart app"
process.env.NODE_ENV = "production";
const hash = crypto.createHash("sha256").update(pw);
$ git push origin main --force-with-lease
const hash = crypto.createHash("sha256").update(pw);
router.get("/api/v1/users", getUsers);
try { await deploy(); } catch (e) { rollback(); }
const { rows } = await pool.query(sql);
module.exports = { config, deploy };
#!/bin/bash
for (let i = 0; i < nodes.length; i++) {
router.get("/api/v1/users", getUsers);
export const middleware = (req, res, next) => {
$ rsync -avz ./dist/ server:/var/www/html/
useEffect(() => { fetchData(); }, [id]);
$ git commit -m "fix: resolve memory leak"
async function handleRequest(req, res) {
if (!token) return res.status(401).json({ error });
if (!token) return res.status(401).json({ error });
$ grep -rn "ERROR" /var/log/app/*.log
$ ssh root@10.0.0.1 "systemctl restart app"
$ npm run build && npm run deploy
$ grep -rn "ERROR" /var/log/app/*.log
SELECT * FROM deployments WHERE status = 1;
server.on("error", (err) => logger.fatal(err));
$ grep -rn "ERROR" /var/log/app/*.log
router.get("/api/v1/users", getUsers);
const db = new PrismaClient();
$ pm2 restart ecosystem.config.js --env prod
$ helm upgrade --install api ./chart
$ git push origin main --force-with-lease
$ terraform plan -var-file=prod.tfvars
Array.from(nodes).filter(n => n.active).map(fn);
setInterval(() => healthCheck(), 30000);
/* eslint-disable no-console */
CREATE INDEX idx_deploy ON builds (created_at);
$ pm2 restart ecosystem.config.js --env prod
addEventListener("DOMContentLoaded", init);
$ docker build -t app:latest .
$ curl -X POST https://api.example.com/deploy
const { rows } = await pool.query(sql);
CREATE INDEX idx_deploy ON builds (created_at);
router.get("/api/v1/users", getUsers);
Object.keys(env).forEach(k => validate(k));
$ git commit -m "fix: resolve memory leak"
func deploy(ctx context.Context) error {
exit 0
$ pm2 restart ecosystem.config.js --env prod
try { await deploy(); } catch (e) { rollback(); }
server.on("error", (err) => logger.fatal(err));
#!/bin/bash
fn main() -> Result<(), Box<dyn Error>> {
addEventListener("DOMContentLoaded", init);
console.log("[INFO] server started on :3000");
SELECT COUNT(*) FROM requests WHERE ts > NOW() - 1h;
addEventListener("DOMContentLoaded", init);
$ certbot renew --nginx --quiet
$ helm upgrade --install api ./chart
await Promise.all(tasks.map(t => t.execute()));
useEffect(() => { fetchData(); }, [id]);
export const middleware = (req, res, next) => {
process.env.NODE_ENV = "production";
exit 0
export default function main() {
fs.writeFileSync("/tmp/config.json", data);
export const middleware = (req, res, next) => {
process.env.NODE_ENV = "production";
INSERT INTO logs (msg, level) VALUES ($1, $2);
$ tail -f /var/log/nginx/access.log
pipe(stream).on("data", chunk => buffer.push(chunk));
module.exports = { config, deploy };
Object.keys(env).forEach(k => validate(k));
const result = await fetch(API_URL);
INSERT INTO logs (msg, level) VALUES ($1, $2);
import React from "react";
export default function main() {
for (let i = 0; i < nodes.length; i++) {
const hash = crypto.createHash("sha256").update(pw);
for (let i = 0; i < nodes.length; i++) {
export default function main() {
$ npm run build && npm run deploy
async function handleRequest(req, res) {
setInterval(() => healthCheck(), 30000);
$ helm upgrade --install api ./chart
$ npm run build && npm run deploy
$ curl -X POST https://api.example.com/deploy
const db = new PrismaClient();
export const middleware = (req, res, next) => {
INSERT INTO logs (msg, level) VALUES ($1, $2);
func deploy(ctx context.Context) error {
$ rsync -avz ./dist/ server:/var/www/html/
const db = new PrismaClient();
$ helm upgrade --install api ./chart
$ helm upgrade --install api ./chart
try { await deploy(); } catch (e) { rollback(); }
router.get("/api/v1/users", getUsers);
export const middleware = (req, res, next) => {
document.querySelector("#root").innerHTML = html;
$ certbot renew --nginx --quiet
Object.keys(env).forEach(k => validate(k));
try { await deploy(); } catch (e) { rollback(); }
def run_pipeline(config: dict) -> None:
$ curl -X POST https://api.example.com/deploy
child_process.exec("nginx -t", callback);
while (queue.length > 0) process(queue.shift());
const token = jwt.sign(payload, SECRET);