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