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