This is a continuation of previous articles on IaC shortcomings and resolutions. With the example of Azure Front Door, we were explaining the use of separate origin groups for logical organization of backend and front-end endpoints. This section talks about route configuration.
A route is the primary directive to Azure Front Door to handle traffic. The route settings define an association between a domain and an origin group. Features such as Pattern-to-match and rulesets enable granular control over traffic to the backend resources.
A routing rule is composed of two major parts, the “left-hand-side” and the “right-hand-side”. Front Door matches the incoming request to the left-hand side of the route while the right-hand side defines how the request gets processed. On the left-hand side, we have the HTTP Protocols, the domain, and the path where these properties are expanded out so that every combination of a protocol, domain and path is a potential match set. On the right-hand side, we have the routing decisions. If caching is not enabled, the requests are routed directly to the backend.
Route matching is all about the “most-specific-request” that matches with the “left-hand-side”. The order of match is always protocol first, followed by the domain and then the path. The Match is always a yes or a no. Yes, there is a route with an exact match on the frontend host or no there is no such match. In the case of a “No”, a bad request error gets sent. After the host matching comes path matching. A similar logic to frontend hosts is used to match the request path. The only difference is that between a yes or a no, an approximate match based on wild card pattern is allowed. And as always, a failed match returns a bad request error.
One of the key differences between an application gateway and Front Door is this hybrid custom-domain and path-based routing combination matching as described above. Application gateway can be either custom-domain based or path-based routing in most deployments but FrontDoor by its nature to being global across different regional resource types, allows for both custom-domain and path-based matches.
The anycast behavior from FrontDoor requires a comprehensive test matrix to avoid any unpredictability with low-latency choices made by default. For a choice of host and path, there can be four test cases at least even for a “/*” path. Predictability also involves trying those requests from various regions.
Thus, separate endpoints, routing and host header all play a role in determining the responses from the Azure Front Door.
Previous articles: https://1drv.ms/w/s!Ashlm-Nw-wnWhO4RqzMcKLnR-r_WSw?e=kTQwQd
#codingexercise
#codingexercise
Position eight queens on a chess board without conflicts:
public static void positionEightQueens(int[][] B, int[][] used, int row) throws Exception {
if (row == 8) {
if (isAllSafe(B)) {
printMatrix(B, B.length, B[0].length);
}
return;
}
for (int k = 0; k < 8; k++) {
if ( isSafe(B, row, k) && isAllSafe(B)) {
B[row][k] = 1;
positionEightQueens(B, used, row + 1);
B[row][k] = 0;
}
}
}
public static boolean isSafe(int[][] B, int p, int q) {
int row = B.length;
int col = B[0].length;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (i == p && j == q) { continue; }
if (B[i][j] == 1) {
boolean notSafe = isOnDiagonal(B, p, q, i, j) ||
isOnVertical(B, p, q, i, j) ||
isOnHorizontal(B, p, q, i, j);
if(notSafe){
return false;
}
}
}
}
return true;
}
public static boolean isAllSafe(int[][] B) {
for (int i = 0; i < B.length; i++) {
for (int j = 0; j < B[0].length; j++) {
if (B[i][j] == 1 && !isSafe(B, i, j)) {
return false;
}
}
}
return true;
}
public static boolean isOnDiagonal(int[][] used, int r1, int c1, int r2, int c2) {
boolean result = false;
int row = used.length;
int col = used[0].length;
for (int k = 0; k < 8; k ++) {
if (r2 - k >= 0 && c2 - k >= 0 && r1 == r2 - k && c1 == c2 - k) {
return true;
}
if (r2 + k < row && c2 + k < col && r1 == r2 + k && c1 == c2 + k) {
return true;
}
if (r2 - k >= 0 && c2 + k < col && r1 == r2 - k && c1 == c2 + k) {
return true;
}
if (r2 + k < row && c2 - k >= 0 && r1 == r2 + k && c1 == c2 - k) {
return true;
}
}
return result;
}
public static boolean isOnVertical(int[][] used, int r1, int c1, int r2, int c2) {
boolean result = false;
int row = used.length;
int col = used[0].length;
for (int k = 0; k < 8; k++) {
if (c2 - k >= 0 && c1 == c2 - k && r1 == r2 ) {
return true;
}
if (c2 + k < row && c1 == c2 + k && r1 == r2) {
return true;
}
}
return result;
}
public static boolean isOnHorizontal(int[][] used, int r1, int c1, int r2, int c2) {
boolean result = false;
int row = used.length;
int col = used[0].length;
for (int k = 0; k < 8; k++) {
if (r2 - k >= 0 && r1 == r2 - k && c1 == c2 ) {
return true;
}
if (r2 + k < row && r1 == r2 + k && c1 == c2) {
return true;
}
}
return result;
}
Sample output:
1 1 2 1 1 1 1 1
1 1 1 1 1 2 1 1
1 1 1 2 1 1 1 1
1 2 1 1 1 1 1 1
1 1 1 1 1 1 1 2
1 1 1 1 2 1 1 1
1 1 1 1 1 1 2 1
2 1 1 1 1 1 1 1
