# הקדמה

די ינאַגריישאַן פון אַרטיפיסיאַל ינטעלליגענסע (AI) אין ווייכווארג אַפּלאַקיישאַנז האט רעוואַלושאַנייזד די וועג מיר צוגאַנג פּראָבלעם סאַלווינג, באַשלוס-מאכן און אָטאַמיישאַן. אָבער, ווי אַי-געטריבן אַפּלאַקיישאַנז ווערן ינקריסינגלי סאַפיסטאַקייטיד, זיי אויך ווערן מער שפּירעוודיק צו ימערדזשינג טרעץ ווי דעעפּפאַקעס און אַי-געטריבן אָטאַמיישאַן. אין דעם אַרטיקל, מיר וועלן ויספאָרשן אַוואַנסירטע טעקניקס פֿאַר דיזיינינג ווייכווארג אַרקאַטעקטשערז וואָס קענען יפעקטיוולי ויסשטימען אַי קאַמפּאָונאַנץ בשעת ינשורינג סקאַלאַביליטי און זיכערהייט.

די טשאַלאַנדזשיז פון אַי-געטריבן אַפּפּליקאַטיאָנס

אַי-געטריבן אַפּלאַקיישאַנז זענען קעראַקטערייזד דורך זייער פיייקייט צו לערנען פון דאַטן, אַדאַפּט זיך צו נייַע סיטואַטיאָנס און מאַכן דיסיזשאַנז אָטאַנאַמאַסלי. אָבער, דאָס אויך מיטל אַז זיי זענען מער סאַסעפּטאַבאַל צו אנפאלן וואָס ציל זייער אַי קאַמפּאָונאַנץ. עטלעכע פון די טשאַלאַנדזשיז פֿאַרבונדן מיט אַי-געטריבן אַפּלאַקיישאַנז אַרייַננעמען:

• ** דעעפּפאַקעס **: אַי-דזשענערייטאַד שווינדל ווידיאס, אַודיאָ רעקאָרדינגס אָדער בילדער וואָס קענען זיין גענוצט צו אָפּנאַרן ניצערס אָדער קאָמפּראָמיס זיכערהייט סיסטעמען.
• ** AI-געטריבן אָטאַמיישאַן **: AI-Powered באָץ וואָס קענען אָטאַמייט אנפאלן, פאַרשפּרייטן מאַלוואַרע אָדער קאָמפּראָמיס שפּירעוודיק דאַטן.
• ** דאַטן פאַרסאַמונג **: אַי מאָדעלס קענען זיין טריינד אויף פּויזאַנד דאַטן, וואָס פירן צו בייאַסט אָדער ומפּינקטלעך רעזולטאַטן.
• ** מאָדעל יקסטראַקשאַן **: אַטאַקערז קענען עקסטראַקט שפּירעוודיק אינפֿאָרמאַציע פון ​​אַי מאָדעלס, קאַמפּראַמייזינג זייער זיכערהייט.

סטראַטעגיעס פֿאַר סקאַלאַביליטי

צו בויען ריזיליאַנט ווייכווארג אַרקאַטעקטשערז פֿאַר אַי-געטריבן אַפּלאַקיישאַנז, מיר דאַרפֿן צו פאָקוס אויף סקאַלאַביליטי. סקאַלאַביליטי רעפערס צו די פיייקייט פון אַ סיסטעם צו שעפּן געוואקסן מאַסע, פאַרקער אָדער דאַטן אָן קאַמפּראַמייזינג פאָרשטעלונג. דאָ זענען עטלעכע סטראַטעגיעס צו דערגרייכן סקאַלאַביליטי אין אַי-געטריבן אַפּלאַקיישאַנז:

1. מיקראָ סערוויסעס אַרטשיטעקטורע

מיקראָסערוויסעס אַרקאַטעקטשער איז אַ פּלאַן מוסטער וואָס סטראַקטשערז אַ אַפּלאַקיישאַן ווי אַ זאַמלונג פון קליין, פרייַ באַדינונגס וואָס יבערגעבן מיט יעדער אנדערע ניצן אַפּיס. דעם צוגאַנג אַלאַוז פֿאַר גרעסערע בייגיקייַט, סקאַלאַביליטי און שולד טאָלעראַנץ.

# ביישפּיל פון אַ מיקראָסערוויס אַרקאַטעקטשער אין פּיטהאָן
פֿון קאָלבע אַרייַנפיר פלאַש, jsonify
פֿון flask_sqlalchemy אַרייַנפיר SQLAlchemy

אַפּ = פלאַש (__ נאָמען__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///example.db"
db = SQLAlchemy (אַפּ)

קלאַס באַניצער(דב.מאָדעל):
    שייַן = דב. קאָלום (דב. ינטעגער, ערשטיק_קיי = אמת)
    נאָמען = db.Column(db.String(100), נולאַבלע = פאַלש)

@app.route("/ יוזערז", מעטהאָדס = ["באַקומען"])
דעפ באַקומען_וסערס():
    ניצערס = User.query.all ()
    צוריקקומען jsonify ([{"id": user.id, "name": user.name} פֿאַר באַניצער אין יוזערז])

אויב __ נאָמען__ == "__ הויפּט __":
    app.run (דעבוג = אמת)

2. קאַנטיינעריזאַטיאָן

קאַנטיינעריזאַטיאָן איז אַ טעכניק וואָס פּאַקידזשיז אַ אַפּלאַקיישאַן און זייַן דיפּענדאַנסיז אין אַ איין קאַנטיינער וואָס קענען זיין לויפן אויף קיין פּלאַטפאָרמע. דער צוגאַנג אַלאַוז פֿאַר גרעסערע פּאָרטאַביליטי, סקאַלאַביליטי און זיכערהייט.

// בייַשפּיל פון קאַנטיינערז אין Go
פּעקל הויפּט

אַרייַנפיר (
	"פמט"
	"לאָג"

	"github.com/docker/docker/api/types/container"
	"github.com/docker/docker/api/types/network"
	"github.com/docker/docker/client"
)

func main() {
	קלי, טעות:= client.NewClientWithOpts(client.FromEnv)
	אויב טעות != נייל {
		לאָג.פאַטאַל (טעות)
	}

	containerConfig:= &container.Config{
		בילד: "בייַשפּיל / בילד",
		ענוו: []שטריקל{"EXAMPLE_VAR=example"},
	}

	נעטוואָרקקאָנפיג:= &נעטוואָרק.נעטוואָרקינג קאָנפיג{
		EndpointsConfig: מאַפּע[שטריקל]*נעטוואָרק.ענדפּאָינטסעטטינגס{
			"example-network": {},
		},
	}

	רעספּ, טעות:= קלי.קאָנטאַינערקרעאַטע(קאָנטעקסט.באַקקגראַונד(), קאַנטיינערקאָנפיג, נעטוואָרקקאָנפיג, נול, נול, "")
	אויב טעות != נייל {
		לאָג.פאַטאַל (טעות)
	}

	fmt.Println(רעספּ.יד)
}

3. סערווערלעסס אַרטשיטעקטורע

סערווערלעסס אַרקאַטעקטשער איז אַ פּלאַן מוסטער וואָס סטראַקטשערז אַ אַפּלאַקיישאַן ווי אַ זאַמלונג פון פאַנגקשאַנז וואָס זענען עקסאַקיוטאַד אויף פאָדערונג, אָן די נויט פֿאַר פּראַוויזשאַנז אָדער אָנפירונג סערווערס. דעם צוגאַנג אַלאַוז פֿאַר גרעסערע סקאַלאַביליטי, בייגיקייַט און קאָס-יפעקטיוונאַס.

// בייַשפּיל פון סערווערלעסס אַרקאַטעקטשער אין רוסט
נוצן lambda_runtime::{קאָנטעקסט, טעות};
נוצן serde_json::json;

#[tokio::main]
async fn main () -> רעזולטאַט <(), טעות> {
    לאָזן פונק = lambda_runtime :: לויפן! (האַנדלער);
    func(Context::default()). אַוואַיט?;
    אָוקיי (())
}

async fn האַנדלער (_event: lambda_runtime:: עווענט, _קאָנטעקסט: קאָנטעקסט) -> רעזולטאַט <lambda_runtime:: רעזולטאַט, טעות> {
    לאָזן רעזולטאַט = json!({
        "סטאַטוס קאָד": 200,
        "body": "העלא פֿון לאַמבדאַ!",
    });
    Ok (lambda_runtime :: רעזולטאַט :: פֿון (רעזולטאַט))
}

סטראַטעגיעס פֿאַר זיכערהייט

צו בויען ריזיליאַנט ווייכווארג אַרקאַטעקטשערז פֿאַר אַי-געטריבן אַפּלאַקיישאַנז, מיר אויך דאַרפֿן צו פאָקוס אויף זיכערהייט. זיכערהייט רעפערס צו די פיייקייט פון אַ סיסטעם צו באַשיצן זיך קעגן אַנאָטערייזד אַקסעס, דאַטן בריטשיז אָדער אנדערע בייזע אַקטיוויטעטן. דאָ זענען עטלעכע סטראַטעגיעס צו דערגרייכן זיכערהייט אין אַי-געטריבן אַפּלאַקיישאַנז:

1. דאַטאַ ענקריפּשאַן

דאַטאַ ענקריפּשאַן איז אַ טעכניק וואָס סקראַמבאַלז דאַטן צו פאַרמייַדן אַנאָטערייזד אַקסעס. דער צוגאַנג אַלאַוז אַ גרעסערע זיכערהייט, קאַנפאַדענשיאַלאַטי און אָרנטלעכקייַט.

# בייַשפּיל פון דאַטן ענקריפּשאַן אין פּיטהאָן
פֿון cryptography.fernet אַרייַנפיר פערנעט

key = Fernet.generate_key()
cipher_suite = פערנעט (שליסל)

דאַטן = ב"העלא, וועלט!"
ענקריפּטעד_דאַטאַ = cipher_suite.encrypt (דאַטאַ)
דרוק (ענקריפּטעד_דאַטן)

דעקריפּטעד_דאַטאַ = cipher_suite.decrypt(ענקריפּטעד_דאַטאַ)
דרוק (דעקריפּטעד_דאַטן)

2. אַקסעס קאָנטראָל

אַקסעס קאָנטראָל איז אַ טעכניק וואָס רעגיאַלייץ ווער קענען אַקסעס שפּירעוודיק דאַטן אָדער דורכפירן זיכער אַקשאַנז. דעם צוגאַנג אַלאַוז פֿאַר מער זיכערהייט, אַקאַונטאַביליטי און העסקעם.

// בייַשפּיל פון אַקסעס קאָנטראָל אין Go
פּעקל הויפּט

אַרייַנפיר (
	"פמט"
	"לאָג"

	"github.com/dgrijalva/jwt-go"
)

func main() {
	טאָקען:= jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"username": "בייַשפּיל",
		"role": "אַדמין",
	})

	tokenString, טעות := token.SignedString([]בייט ("סוד"))
	אויב טעות != נייל {
		לאָג.פאַטאַל (טעות)
	}

	fmt.Println(טאָקעןסטרינג)
}

3. אַנאַמאַלי דעטעקשאַן

אַנאַמאַלי דיטעקשאַן איז אַ טעכניק וואָס יידענאַפייד ומגעוויינטלעך פּאַטערנז אָדער נאַטור אין דאַטן. דער צוגאַנג אַלאַוז פֿאַר מער זיכערהייט, דיטעקשאַן און ענטפער.

// בייַשפּיל פון אַנאַמאַלי דיטעקשאַן אין זשאַווער
נוצן ראַנד::רנג;
נוצן std::collections::HashMap;

fn main() {
    לאָזן מוט רנג = ראַנד :: טרעאַד_רנג ();
    לאָזן מוט דאַטן = האַשמאַפּ :: נייַ ();

    פֿאַר _ אין 0..100 {
        לאָזן ווערט = rng.gen_range (0..100);
        דאַטאַ.ינסערט (ווערט, ווערט);
    }

    לאָזן אַנאַמאַליז = וועק:: נייַ ();

    פֿאַר (שליסל, ווערט) אין data.iter () {
        אויב * שליסל > 50 && * ווערט > 50 {
            anomalies.push(key.clone());
        }
    }

    println!("{:?}", אַנאַמאַליעס);
}

וויסואַליזאַטיאָן

דאָ איז אַ ביישפּיל פון וויזשוואַלאַזיישאַן ניצן Chart.js צו אילוסטרירן די סקאַלאַביליטי און זיכערהייט סטראַטעגיעס דיסקאַסט אין דעם אַרטיקל.

{
  "type": "באַר",
  "דאַטן": {
    "labels": ["מיקראָ סערוויסעס", "קאָנטאַינעריזאַטיאָן", "סערווערלעסס"],
    "דאַטאַסעטס": [
      {
        "label": "סקאַלאַביליטי",
        "דאַטן": [10, 20, 30],
        "backgroundColor": [
          "rgba(255, 99, 132, 0.2)",
          "rgba(54, 162, 235, 0.2)",
          "רגבאַ(255, 206, 86, 0.2)"
        ],
        "borderColor": [
          "rgba(255, 99, 132, 1)",
          "rgba(54, 162, 235, 1)",
          "רגבאַ(255, 206, 86, 1)"
        ],
        "borderWidth": [1, 1, 1]
      },
      {
        "label": "זיכערהייט",
        "דאַטן": [20, 30, 40],
        "backgroundColor": [
          "rgba(255, 99, 132, 0.2)",
          "rgba(54, 162, 235, 0.2)",
          "רגבאַ(255, 206, 86, 0.2)"
        ],
        "borderColor": [
          "rgba(255, 99, 132, 1)",
          "rgba(54, 162, 235, 1)",
          "רגבאַ(255, 206, 86, 1)"
        ],
        "borderWidth": [1, 1, 1]
      }
    ]
  },
  "אָפּציעס": {
    "סקאַלעס": {
      "יאַקסעס": [
        {
          "טיקס": {
            "באַגינאַט זעראָ": אמת
          }
        }
      ]
    }
  }
}

די וויזשוואַלאַזיישאַן ילאַסטרייץ די סקאַלאַביליטי און זיכערהייט בענעפיץ פון יעדער סטראַטעגיע, מיט מיקראָסערוויסעס ווייַזן די העכסטן סקאַלאַביליטי און סערווערלעסס ווייַזן די העכסטן זיכערהייט.

# מסקנא

בנין ריזיליאַנט ווייכווארג אַרקאַטעקטשערז פֿאַר אַי-געטריבן אַפּלאַקיישאַנז ריקווייערז אַ קאָמבינאַציע פון סקאַלאַביליטי און זיכערהייט סטראַטעגיעס. דורך פאָוקיסינג אויף מיקראָסערוויסעס אַרקאַטעקטשער, קאַנטיינערז און סערווערלעסס אַרקאַטעקטשער, מיר קענען דערגרייכן גרעסערע סקאַלאַביליטי און בייגיקייַט. דורך פאָוקיסינג אויף דאַטן ענקריפּשאַן, אַקסעס קאָנטראָל און אַנאַמאַלי דיטעקשאַן, מיר קענען דערגרייכן אַ גרעסערע זיכערהייט און שוץ. דורך קאַמביינינג די סטראַטעגיעס, מיר קענען בויען ווייכווארג אַרקאַטעקטשערז וואָס זענען סקאַלאַבלע און זיכער, און קענען יפעקטיוולי ויסשטימען אַי קאַמפּאָונאַנץ בשעת ינשורינג די זיכערהייט און אָרנטלעכקייַט פון אונדזער אַפּלאַקיישאַנז.

# רעפערענצן

• [1] "Microservices Architecture" דורך Martin Fowler
• [2] "קאָנטאַינעריזאַטיאָן" דורך דאָקער
• [3] "סערווערלעסס אַרטשיטעקטורע" דורך AWS
• [4] "דאַטאַ ענקריפּשאַן" דורך קריפּטאָגראַפי
• [5] "אַקסעס קאָנטראָל" דורך JWT
• [6] "אַנאַמאַלי דעטעקשאַן" דורך מאַשין לערנען

באַמערקונג: דער אַרטיקל איז בלויז פֿאַר בילדונגקרייז צוועקן און זאָל ניט זיין גערעכנט ווי אַ פולשטענדיק וועגווייַזער צו בויען ריזיליאַנט ווייכווארג אַרקאַטעקטשערז פֿאַר אַי-געטריבן אַפּלאַקיישאַנז.